rating 0.1.0 → 0.2.0

data/spec/models/extension/rating_records_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Rating::Extension, '.rating' do
+  let!(:category) { create :category }
+
+  let!(:user_1) { create :user }
+  let!(:user_2) { create :user }
+
+  let!(:article_1) { create :article }
+  let!(:article_2) { create :article }
+  let!(:article_3) { create :article }
+
+  before do
+    create :rating_rate, author: user_1, resource: article_1, value: 100
+    create :rating_rate, author: user_1, resource: article_2, value: 11
+    create :rating_rate, author: user_1, resource: article_3, value: 10
+    create :rating_rate, author: user_2, resource: article_1, value: 1
+
+    create :rating_rate, author: user_1, resource: article_1, scopeable: category, value: 1
+    create :rating_rate, author: user_2, resource: article_1, scopeable: category, value: 2
+  end
+
+  it 'returns all rating of this resource' do
+    expect(article_1.rating_records).to match_array Rating::Rating.where(resource: article_1)
+  end
+end

data/spec/models/extension/rating_spec.rb

@@ -2,37 +2,53 @@
 
 require 'rails_helper'
 
-RSpec.describe Rating::Extension, ':rating' do
-  let!(:user_1)  { create :user }
-  let!(:article) { create :article }
+RSpec.describe Rating::Extension, '.rating' do
+  let!(:category) { create :category }
 
-  before { user_1.rate article, 1 }
+  let!(:user_1) { create :user }
+  let!(:user_2) { create :user }
 
-  it 'returns rating record' do
-    expect(article.rating).to eq Rating::Rating.last
-  end
+  let!(:article_1) { create :article }
+  let!(:article_2) { create :article }
+  let!(:article_3) { create :article }
 
-  context 'when destroy author' do
-    let!(:user_2) { create :user }
+  let!(:rate_1) { create :rating_rate, author: user_1, resource: article_1, value: 100 }
+  let!(:rate_2) { create :rating_rate, author: user_1, resource: article_2, value: 11 }
+  let!(:rate_3) { create :rating_rate, author: user_1, resource: article_3, value: 10 }
+  let!(:rate_4) { create :rating_rate, author: user_2, resource: article_1, value: 1 }
+
+  let!(:rate_5) { create :rating_rate, author: user_1, resource: article_1, scopeable: category, value: 1 }
+  let!(:rate_6) { create :rating_rate, author: user_2, resource: article_1, scopeable: category, value: 2 }
 
-    before { user_2.rate article, 2 }
+  context 'with no scope' do
+    it 'returns rating record' do
+      expect(article_1.rating).to eq Rating::Rating.find_by(resource: article_1, scopeable: nil)
+    end
+  end
 
+  context 'with scope' do
+    it 'returns scoped rating record' do
+      expect(article_1.rating(scope: category)).to eq Rating::Rating.find_by(resource: article_1, scopeable: category)
+    end
+  end
+
+  context 'when destroy author' do
     it 'does not destroy resource rating' do
-      expect(Rating::Rating.where(resource: article).count).to eq 1
+      expect(Rating::Rating.where(resource: article_1).count).to eq 2
 
       user_1.destroy!
 
-      expect(Rating::Rating.where(resource: article).count).to eq 1
+      expect(Rating::Rating.where(resource: article_1).count).to eq 2
     end
   end
 
   context 'when destroy resource' do
     it 'destroys resource rating too' do
-      expect(Rating::Rating.where(resource: article).count).to eq 1
+      expect(Rating::Rating.where(resource: article_1).count).to eq 2
 
-      article.destroy!
+      article_1.destroy!
 
-      expect(Rating::Rating.where(resource: article).count).to eq 0
+      expect(Rating::Rating.where(resource: article_1).count).to eq 0
     end
   end
 end

data/spec/models/rate/create_spec.rb

@@ -6,59 +6,126 @@ RSpec.describe Rating::Rate, ':create' do
   let!(:user)    { create :user }
   let!(:article) { create :article }
 
-  before { create :rating_rate, author: user, resource: article, value: 3 }
+  context 'with no scopeable' do
+    before { create :rating_rate, author: user, resource: article, value: 3 }
+
+    context 'when rate does not exist yet' do
+      it 'creates a rate entry' do
+        rate = described_class.last
+
+        expect(rate.author).to   eq user
+        expect(rate.resource).to eq article
+        expect(rate.value).to    eq 3
+      end
+
+      it 'creates a rating entry' do
+        rating = Rating::Rating.last
+
+        expect(rating.average).to  eq 3
+        expect(rating.estimate).to eq 3
+        expect(rating.resource).to eq article
+        expect(rating.sum).to      eq 3
+        expect(rating.total).to    eq 1
+      end
+    end
 
-  context 'when rate does not exist yet' do
-    it 'creates a rate entry' do
-      rate = described_class.last
+    context 'when rate already exists' do
+      let!(:user_2) { create :user }
 
-      expect(rate.author).to   eq user
-      expect(rate.resource).to eq article
-      expect(rate.value).to    eq 3
-    end
+      before { create :rating_rate, author: user_2, resource: article, value: 4 }
+
+      it 'creates one more rate entry' do
+        rates = described_class.where(author: [user, user_2]).order('created_at asc')
+
+        expect(rates.size).to eq 2
+
+        rate = rates[0]
+
+        expect(rate.author).to   eq user
+        expect(rate.resource).to eq article
+        expect(rate.value).to    eq 3
+
+        rate = rates[1]
+
+        expect(rate.author).to   eq user_2
+        expect(rate.resource).to eq article
+        expect(rate.value).to    eq 4
+      end
 
-    it 'creates a rating entry' do
-      rating = Rating::Rating.last
+      it 'updates the unique rating entry' do
+        rating = Rating::Rating.find_by(resource: article)
 
-      expect(rating.average).to  eq 3
-      expect(rating.estimate).to eq 3
-      expect(rating.resource).to eq article
-      expect(rating.sum).to      eq 3
-      expect(rating.total).to    eq 1
+        expect(rating.average).to  eq 3.5
+        expect(rating.estimate).to eq 3.5
+        expect(rating.resource).to eq article
+        expect(rating.sum).to      eq 7
+        expect(rating.total).to    eq 2
+      end
     end
   end
 
-  context 'when rate already exists' do
-    let!(:user_2) { create :user }
+  context 'with scopeable' do
+    let!(:category) { create :category }
 
-    before { create :rating_rate, author: user_2, resource: article, value: 4 }
+    before { create :rating_rate, author: user, resource: article, scopeable: category, value: 3 }
 
-    it 'creates one more rate entry' do
-      rates = described_class.where(author: [user, user_2]).order('created_at asc')
+    context 'when rate does not exist yet' do
+      it 'creates a rate entry' do
+        rate = described_class.last
 
-      expect(rates.size).to eq 2
+        expect(rate.author).to    eq user
+        expect(rate.resource).to  eq article
+        expect(rate.scopeable).to eq category
+        expect(rate.value).to     eq 3
+      end
 
-      rate = rates[0]
+      it 'creates a rating entry' do
+        rating = Rating::Rating.last
 
-      expect(rate.author).to   eq user
-      expect(rate.resource).to eq article
-      expect(rate.value).to    eq 3
+        expect(rating.average).to   eq 3
+        expect(rating.estimate).to  eq 3
+        expect(rating.resource).to  eq article
+        expect(rating.scopeable).to eq category
+        expect(rating.sum).to       eq 3
+        expect(rating.total).to     eq 1
+      end
+    end
 
-      rate = rates[1]
+    context 'when rate already exists' do
+      let!(:user_2) { create :user }
 
-      expect(rate.author).to   eq user_2
-      expect(rate.resource).to eq article
-      expect(rate.value).to    eq 4
-    end
+      before { create :rating_rate, author: user_2, resource: article, scopeable: category, value: 4 }
+
+      it 'creates one more rate entry' do
+        rates = described_class.where(author: [user, user_2]).order('created_at asc')
+
+        expect(rates.size).to eq 2
+
+        rate = rates[0]
+
+        expect(rate.author).to    eq user
+        expect(rate.resource).to  eq article
+        expect(rate.scopeable).to eq category
+        expect(rate.value).to     eq 3
+
+        rate = rates[1]
+
+        expect(rate.author).to    eq user_2
+        expect(rate.resource).to  eq article
+        expect(rate.scopeable).to eq category
+        expect(rate.value).to     eq 4
+      end
 
-    it 'updates the unique rating entry' do
-      rating = Rating::Rating.find_by(resource: article)
+      it 'updates the unique rating entry' do
+        rating = Rating::Rating.find_by(resource: article, scopeable: category)
 
-      expect(rating.average).to  eq 3.5
-      expect(rating.estimate).to eq 3.5
-      expect(rating.resource).to eq article
-      expect(rating.sum).to      eq 7
-      expect(rating.total).to    eq 2
+        expect(rating.average).to   eq 3.5
+        expect(rating.estimate).to  eq 3.5
+        expect(rating.resource).to  eq article
+        expect(rating.scopeable).to eq category
+        expect(rating.sum).to       eq 7
+        expect(rating.total).to     eq 2
+      end
     end
   end
 end

data/spec/models/rate/rate_for_spec.rb

@@ -6,15 +6,35 @@ RSpec.describe Rating::Rate, ':rate_for' do
   let!(:user)    { create :user }
   let!(:article) { create :article }
 
-  context 'when rate does not exist' do
-    specify { expect(described_class.rate_for(author: user, resource: article)).to eq nil }
+  context 'with no scopeable' do
+    context 'when rate does not exist' do
+      specify { expect(described_class.rate_for(author: user, resource: article)).to eq nil }
+    end
+
+    context 'when rate does not exist' do
+      before { described_class.create author: user, resource: article, value: 3 }
+
+      it 'returns the record' do
+        expect(described_class.rate_for(author: user, resource: article)).to eq described_class.last
+      end
+    end
   end
 
-  context 'when rate does not exist' do
-    before { described_class.create author: user, resource: article, value: 3 }
+  context 'with scopeable' do
+    let!(:category) { create :category }
+
+    context 'when rate does not exist' do
+      specify { expect(described_class.rate_for(author: user, resource: article, scopeable: category)).to eq nil }
+    end
+
+    context 'when rate does not exist' do
+      before { described_class.create author: user, resource: article, scopeable: category, value: 3 }
+
+      it 'returns the record' do
+        query = described_class.rate_for(author: user, resource: article, scopeable: category)
 
-    it 'returns the record' do
-      expect(described_class.rate_for(author: user, resource: article)).to eq described_class.last
+        expect(query).to eq described_class.last
+      end
     end
   end
 end

data/spec/models/rate_spec.rb

@@ -9,6 +9,7 @@ RSpec.describe Rating::Rate do
 
   it { is_expected.to belong_to :author }
   it { is_expected.to belong_to :resource }
+  it { is_expected.to belong_to :scopeable }
 
   it { is_expected.to validate_presence_of :author }
   it { is_expected.to validate_presence_of :resource }
@@ -20,7 +21,7 @@ RSpec.describe Rating::Rate do
 
   specify do
     expect(object).to validate_uniqueness_of(:author_id)
-      .scoped_to(%i[author_type resource_id resource_type])
+      .scoped_to(%i[author_type resource_id resource_type scopeable_id scopeable_type])
       .case_insensitive
   end
 end

data/spec/models/rating/averager_data_spec.rb

@@ -3,7 +3,7 @@
 require 'rails_helper'
 
 RSpec.describe Rating::Rating, ':averager_data' do
-  subject { described_class.averager_data article_1 }
+  let!(:category) { create :category }
 
   let!(:user_1) { create :user }
   let!(:user_2) { create :user }
@@ -17,13 +17,32 @@ RSpec.describe Rating::Rating, ':averager_data' do
     create :rating_rate, author: user_1, resource: article_2, value: 11
     create :rating_rate, author: user_1, resource: article_3, value: 10
     create :rating_rate, author: user_2, resource: article_1, value: 1
+
+    create :rating_rate, author: user_1, resource: article_1, scopeable: category, value: 1
+    create :rating_rate, author: user_2, resource: article_1, scopeable: category, value: 2
   end
 
-  it 'returns the values average of given resource type' do
-    expect(subject.as_json['rating_avg']).to eq 30.5
+  context 'with no scopeable' do
+    subject { described_class.averager_data article_1, nil }
+
+    it 'returns the values average of given resource type' do
+      expect(subject.as_json['rating_avg']).to eq 30.5
+    end
+
+    it 'returns the average of number of records for the given resource type' do
+      expect(subject.as_json['count_avg']).to eq 1.3333333333333333
+    end
   end
 
-  it 'returns the average of number of records for the given resource type' do
-    expect(subject.as_json['count_avg']).to eq 1.3333333333333333
+  context 'with scopeable' do
+    subject { described_class.averager_data article_1, category }
+
+    it 'returns the values average of given resource type' do
+      expect(subject.as_json['rating_avg']).to eq 1.5
+    end
+
+    it 'returns the average of number of records for the given resource type' do
+      expect(subject.as_json['count_avg']).to eq 2
+    end
   end
 end

data/spec/models/rating/data_spec.rb

@@ -3,7 +3,7 @@
 require 'rails_helper'
 
 RSpec.describe Rating::Rating, ':data' do
-  subject { described_class.data article_1 }
+  let!(:category) { create :category }
 
   let!(:user_1) { create :user }
   let!(:user_2) { create :user }
@@ -17,21 +17,48 @@ RSpec.describe Rating::Rating, ':data' do
     create :rating_rate, author: user_1, resource: article_2, value: 11
     create :rating_rate, author: user_1, resource: article_3, value: 10
     create :rating_rate, author: user_2, resource: article_1, value: 1
-  end
 
-  it 'returns the average of value for a resource' do
-    expect(subject[:average]).to eq 50.5
+    create :rating_rate, author: user_1, resource: article_1, scopeable: category, value: 1
+    create :rating_rate, author: user_2, resource: article_1, scopeable: category, value: 2
   end
 
-  it 'returns the sum of values for a resource' do
-    expect(subject[:sum]).to eq 101
-  end
+  context 'with no scopeable' do
+    subject { described_class.data article_1, nil }
+
+    it 'returns the average of value for a resource' do
+      expect(subject[:average]).to eq 50.5
+    end
+
+    it 'returns the sum of values for a resource' do
+      expect(subject[:sum]).to eq 101
+    end
+
+    it 'returns the count of votes for a resource' do
+      expect(subject[:total]).to eq 2
+    end
 
-  it 'returns the count of votes for a resource' do
-    expect(subject[:total]).to eq 2
+    it 'returns the estimate for a resource' do
+      expect(subject[:estimate]).to eq 42.50000000000001
+    end
   end
 
-  it 'returns the estimate for a resource' do
-    expect(subject[:estimate]).to eq 42.50000000000001
+  context 'with scopeable' do
+    subject { described_class.data article_1, category }
+
+    it 'returns the average of value for a resource' do
+      expect(subject[:average]).to eq 1.5
+    end
+
+    it 'returns the sum of values for a resource' do
+      expect(subject[:sum]).to eq 3
+    end
+
+    it 'returns the count of votes for a resource' do
+      expect(subject[:total]).to eq 2
+    end
+
+    it 'returns the estimate for a resource' do
+      expect(subject[:estimate]).to eq 1.5
+    end
   end
 end

data/spec/models/rating/update_rating_spec.rb

@@ -3,6 +3,8 @@
 require 'rails_helper'
 
 RSpec.describe Rating::Rating, ':update_rating' do
+  let!(:category) { create :category }
+
   let!(:user_1) { create :user }
   let!(:user_2) { create :user }
 
@@ -15,14 +17,30 @@ RSpec.describe Rating::Rating, ':update_rating' do
     create :rating_rate, author: user_1, resource: article_2, value: 11
     create :rating_rate, author: user_1, resource: article_3, value: 10
     create :rating_rate, author: user_2, resource: article_1, value: 1
+
+    create :rating_rate, author: user_1, resource: article_1, scopeable: category, value: 1
+    create :rating_rate, author: user_2, resource: article_1, scopeable: category, value: 2
+  end
+
+  context 'with no scopeable' do
+    it 'updates the rating data of the given resource' do
+      record = described_class.find_by(resource: article_1)
+
+      expect(record.average).to  eq 50.50000000000001
+      expect(record.estimate).to eq 42.50000000000001
+      expect(record.sum).to      eq 101
+      expect(record.total).to    eq 2
+    end
   end
 
-  it 'updates the rating data of the given resource' do
-    record = described_class.find_by(resource: article_1)
+  context 'with scopeable' do
+    it 'updates the rating data of the given resource respecting the scope' do
+      record = described_class.find_by(resource: article_1, scopeable: category)
 
-    expect(record.average).to  eq 50.50000000000001
-    expect(record.estimate).to eq 42.50000000000001
-    expect(record.sum).to      eq 101
-    expect(record.total).to    eq 2
+      expect(record.average).to  eq 1.5
+      expect(record.estimate).to eq 1.5
+      expect(record.sum).to      eq 3
+      expect(record.total).to    eq 2
+    end
   end
 end