rating 0.11.0 → 0.12.0

data/spec/models/extension/unscoped_rating_spec.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Rating::Extension, 'unscoped_rating' do
-  let!(:author_1) { create :author }
-  let!(:author_2) { create :author }
-  let!(:author_3) { create :author }
-  let!(:scope)    { create :category }
-
-  context 'when is false' do
-    let!(:resource) { create :article }
-
-    it 'groups in different line record' do
-      author_1.rate resource, 1, scope: scope
-      author_2.rate resource, 2, scope: scope
-      author_2.rate resource, 5
-
-      ratings = Rating::Rating.all.order('id')
-
-      expect(ratings.size).to eq 2
-
-      rating = ratings[0]
-
-      expect(rating.average.to_s).to  eq '1.5'
-      expect(rating.estimate.to_s).to eq '1.5'
-      expect(rating.resource).to      eq resource
-      expect(rating.scopeable).to     eq scope
-      expect(rating.sum).to           eq 3
-      expect(rating.total).to         eq 2
-
-      rating = ratings[1]
-
-      expect(rating.average.to_s).to  eq '5.0'
-      expect(rating.estimate.to_s).to eq '5.0'
-      expect(rating.resource).to      eq resource
-      expect(rating.scopeable).to     eq nil
-      expect(rating.sum).to           eq 5
-      expect(rating.total).to         eq 1
-    end
-  end
-
-  context 'when is true' do
-    let!(:resource) { create :global }
-
-    it 'groups in the same line record' do
-      author_1.rate resource, 1, scope: scope
-      author_2.rate resource, 2, scope: scope
-      author_2.rate resource, 5
-
-      ratings = Rating::Rating.all.order('id')
-
-      expect(ratings.size).to eq 1
-
-      rating = ratings[0]
-
-      expect(rating.average.to_s).to  eq '2.6666666666666667'
-      expect(rating.estimate.to_s).to eq '2.6666666666666667'
-      expect(rating.resource).to      eq resource
-      expect(rating.scopeable).to     eq nil
-      expect(rating.sum).to           eq 8
-      expect(rating.total).to         eq 3
-    end
-  end
-
-  context 'when is true and have a non scoped record first on database' do
-    let!(:resource) { create :global }
-
-    before { ::Rating::Rating.create resource: resource, scopeable: scope }
-
-    it 'sets the result on record with no scope' do
-      author_1.rate resource, 1, scope: scope
-      author_2.rate resource, 2, scope: scope
-      author_3.rate resource, 5
-
-      ratings = Rating::Rating.all.order('id')
-
-      expect(ratings.size).to eq 2
-
-      rating = ratings[0]
-
-      expect(rating.average.to_s).to  eq '0.0'
-      expect(rating.estimate.to_s).to eq '0.0'
-      expect(rating.resource).to      eq resource
-      expect(rating.scopeable).to     eq scope
-      expect(rating.sum).to           eq 0
-      expect(rating.total).to         eq 0
-
-      rating = ratings[1]
-
-      expect(rating.average.to_s).to  eq '2.6666666666666667'
-      expect(rating.estimate.to_s).to eq '2.6666666666666667'
-      expect(rating.resource).to      eq resource
-      expect(rating.scopeable).to     eq nil
-      expect(rating.sum).to           eq 8
-      expect(rating.total).to         eq 3
-    end
-  end
-end

data/spec/models/extension/where_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Rating::Extension, 'unscoped_rating' do
-  let!(:author_1) { create :author }
-  let!(:author_2) { create :author }
-  let!(:author_3) { create :author }
-  let!(:author_4) { create :author }
-  let!(:author_5) { create :author }
-  let!(:resource) { create :toy }
-
-  it 'uses rate with where condition' do
-    author_1.rate resource, 1
-    author_2.rate resource, 2
-    author_3.rate resource, 3
-    author_4.rate resource, 4
-    author_5.rate resource, 5
-
-    ratings = Rating::Rating.all.order('id')
-
-    expect(ratings.size).to eq 1
-
-    rating = ratings[0]
-
-    expect(rating.average.to_s).to  eq '3.0'
-    expect(rating.estimate.to_s).to eq '3.0'
-    expect(rating.resource).to      eq resource
-    expect(rating.scopeable).to     eq nil
-    expect(rating.sum).to           eq 9
-    expect(rating.total).to         eq 3
-  end
-end

data/spec/models/rate/create_spec.rb

@@ -1,422 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Rating::Rate, ':create' do
-  let!(:author)  { create :author }
-  let!(:article) { create :article }
-
-  context 'with no scopeable' do
-    before { described_class.create author: author, extra_scopes: {}, metadata: {}, 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 author
-        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 already exists' do
-      let!(:author_2) { create :author }
-
-      before { described_class.create author: author_2, extra_scopes: {}, metadata: {}, resource: article, value: 4 }
-
-      it 'creates one more rate entry' do
-        rates = described_class.where(author: [author, author_2]).order('created_at asc')
-
-        expect(rates.size).to eq 2
-
-        rate = rates[0]
-
-        expect(rate.author).to   eq author
-        expect(rate.resource).to eq article
-        expect(rate.value).to    eq 3
-
-        rate = rates[1]
-
-        expect(rate.author).to   eq author_2
-        expect(rate.resource).to eq article
-        expect(rate.value).to    eq 4
-      end
-
-      it 'updates the unique rating entry' do
-        rating = Rating::Rating.find_by(resource: article)
-
-        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 'with scopeable' do
-    let!(:category) { create :category }
-
-    before do
-      described_class.create(
-        author:       author,
-        extra_scopes: {},
-        metadata:     {},
-        resource:     article,
-        scopeable:    category,
-        value:        3
-      )
-    end
-
-    context 'when rate does not exist yet' do
-      it 'creates a rate entry' do
-        rate = described_class.last
-
-        expect(rate.author).to    eq author
-        expect(rate.resource).to  eq article
-        expect(rate.scopeable).to eq category
-        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.scopeable).to eq category
-        expect(rating.sum).to       eq 3
-        expect(rating.total).to     eq 1
-      end
-    end
-
-    context 'when rate already exists' do
-      let!(:author_2) { create :author }
-
-      before do
-        described_class.create(
-          author:       author_2,
-          extra_scopes: {},
-          metadata:     {},
-          resource:     article,
-          scopeable:    category,
-          value:        4
-        )
-      end
-
-      it 'creates one more rate entry' do
-        rates = described_class.where(author: [author, author_2]).order('created_at asc')
-
-        expect(rates.size).to eq 2
-
-        rate = rates[0]
-
-        expect(rate.author).to    eq author
-        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 author_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, scopeable: category)
-
-        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
-
-  context 'with metadata' do
-    context 'with nil value' do
-      it 'creates a rate entry ignoring metadata' do
-        described_class.create author: author, extra_scopes: {}, metadata: nil, resource: article, value: 3
-
-        rate = described_class.last
-
-        expect(rate.author).to   eq author
-        expect(rate.comment).to  eq nil
-        expect(rate.resource).to eq article
-        expect(rate.value).to    eq 3
-      end
-    end
-
-    context 'with empty value' do
-      it 'creates a rate entry ignoring metadata' do
-        described_class.create author: author, extra_scopes: {}, metadata: '', resource: article, value: 3
-
-        rate = described_class.last
-
-        expect(rate.author).to   eq author
-        expect(rate.comment).to  eq nil
-        expect(rate.resource).to eq article
-        expect(rate.value).to    eq 3
-      end
-    end
-
-    context 'with hash value' do
-      it 'creates a rate entry with metadata included' do
-        described_class.create(
-          author:       author,
-          extra_scopes: {},
-          metadata:     { comment: 'comment' },
-          resource:     article,
-          value:        3
-        )
-
-        rate = described_class.last
-
-        expect(rate.author).to   eq author
-        expect(rate.comment).to  eq 'comment'
-        expect(rate.resource).to eq article
-        expect(rate.value).to    eq 3
-      end
-    end
-
-    context 'when already has an entry' do
-      before do
-        described_class.create(
-          author:       author,
-          extra_scopes: {},
-          metadata:     { comment: 'comment' },
-          resource:     article,
-          value:        1
-        )
-      end
-
-      context 'when value is the same' do
-        it 'still updates metadata' do
-          described_class.create(
-            author:       author,
-            extra_scopes: {},
-            metadata:     { comment: 'comment.updated' },
-            resource:     article,
-            value:        1
-          )
-
-          rates = described_class.all
-
-          expect(rates.size).to eq 1
-
-          rate = rates[0]
-
-          expect(rate.author).to   eq author
-          expect(rate.comment).to  eq 'comment.updated'
-          expect(rate.resource).to eq article
-          expect(rate.value).to    eq 1
-        end
-      end
-
-      context 'when value is different same' do
-        it 'still updates metadata' do
-          described_class.create(
-            author:       author,
-            extra_scopes: {},
-            metadata:     { comment: 'comment.updated' },
-            resource:     article,
-            value:        2
-          )
-
-          rates = described_class.all
-
-          expect(rates.size).to eq 1
-
-          rate = rates[0]
-
-          expect(rate.author).to   eq author
-          expect(rate.comment).to  eq 'comment.updated'
-          expect(rate.resource).to eq article
-          expect(rate.value).to    eq 2
-        end
-      end
-    end
-  end
-
-  if ENV['CONFIG_ENABLED_WITH_EXTRA_SCOPES'] == 'true'
-    context 'with extra scopes' do
-      let!(:category) { create :category }
-
-      it 'creates a rate entry' do
-        described_class.create(
-          author:       author,
-          extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_2' },
-          metadata:     {},
-          resource:     article,
-          scopeable:    category,
-          value:        1
-        )
-
-        rate = described_class.last
-
-        expect(rate.author).to    eq author
-        expect(rate.resource).to  eq article
-        expect(rate.scope_1).to   eq 'scope_1'
-        expect(rate.scope_2).to   eq 'scope_2'
-        expect(rate.scopeable).to eq category
-        expect(rate.value).to     eq 1
-      end
-
-      it 'creates a rating entry' do
-        described_class.create(
-          author:       author,
-          extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_2' },
-          metadata:     {},
-          resource:     article,
-          scopeable:    category,
-          value:        1
-        )
-
-        rating = Rating::Rating.last
-
-        expect(rating.average).to   eq 1
-        expect(rating.estimate).to  eq 1
-        expect(rating.resource).to  eq article
-        expect(rating.scopeable).to eq category
-        expect(rating.sum).to       eq 1
-        expect(rating.total).to     eq 1
-      end
-
-      context 'when rate already exists' do
-        before do
-          described_class.create(
-            author:       author,
-            extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_2' },
-            metadata:     {},
-            resource:     article,
-            scopeable:    category,
-            value:        1
-          )
-        end
-
-        it 'updates the rate entry' do
-          described_class.create(
-            author:       author,
-            extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_2' },
-            metadata:     {},
-            resource:     article,
-            scopeable:    category,
-            value:        2
-          )
-
-          rates = described_class.all
-
-          expect(rates.size).to eq 1
-
-          rate = rates[0]
-
-          expect(rate.author).to    eq author
-          expect(rate.resource).to  eq article
-          expect(rate.scope_1).to   eq 'scope_1'
-          expect(rate.scope_2).to   eq 'scope_2'
-          expect(rate.scopeable).to eq category
-          expect(rate.value).to     eq 2
-        end
-
-        it 'updates the unique rating entry' do
-          described_class.create(
-            author:       author,
-            extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_2' },
-            metadata:     {},
-            resource:     article,
-            scopeable:    category,
-            value:        2
-          )
-
-          ratings = Rating::Rating.all
-
-          expect(ratings.size).to eq 1
-
-          rating = ratings[0]
-
-          expect(rating.average).to   eq 2
-          expect(rating.estimate).to  eq 2
-          expect(rating.resource).to  eq article
-          expect(rating.scopeable).to eq category
-          expect(rating.sum).to       eq 2
-          expect(rating.total).to     eq 1
-        end
-      end
-
-      context 'when rate already exists but with at least one extra scope different' do
-        before do
-          described_class.create(
-            author:       author,
-            extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_2' },
-            metadata:     {},
-            resource:     article,
-            scopeable:    category,
-            value:        1
-          )
-
-          described_class.create(
-            author:       author,
-            extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_missing' },
-            metadata:     {},
-            resource:     article,
-            scopeable:    category,
-            value:        2
-          )
-        end
-
-        it 'creates a new rate entry' do
-          rates = described_class.all
-
-          expect(rates.size).to eq 2
-
-          rate = rates[0]
-
-          expect(rate.author).to    eq author
-          expect(rate.resource).to  eq article
-          expect(rate.scope_1).to   eq 'scope_1'
-          expect(rate.scope_2).to   eq 'scope_2'
-          expect(rate.scopeable).to eq category
-          expect(rate.value).to     eq 1
-
-          rate = rates[1]
-
-          expect(rate.author).to    eq author
-          expect(rate.resource).to  eq article
-          expect(rate.scope_1).to   eq 'scope_1'
-          expect(rate.scope_2).to   eq 'scope_missing'
-          expect(rate.scopeable).to eq category
-          expect(rate.value).to     eq 2
-        end
-
-        it 'updates the unique rating entry' do
-          ratings = Rating::Rating.all
-
-          expect(ratings.size).to eq 1
-
-          rating = ratings[0]
-
-          expect(rating.average).to   eq 1.5
-          expect(rating.estimate).to  eq 1.5
-          expect(rating.resource).to  eq article
-          expect(rating.scopeable).to eq category
-          expect(rating.sum).to       eq 3
-          expect(rating.total).to     eq 2
-        end
-      end
-    end
-  end
-end

data/spec/models/rate/rate_for_spec.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Rating::Rate, ':rate_for' do
-  let!(:author)  { create :author }
-  let!(:article) { create :article }
-
-  context 'with no scopeable' do
-    context 'when rate does not exist' do
-      it { expect(described_class.rate_for(author: author, resource: article)).to eq nil }
-    end
-
-    context 'when rate exists' do
-      let!(:record) do
-        described_class.create author: author, extra_scopes: {}, metadata: {}, resource: article, value: 3
-      end
-
-      it 'returns the record' do
-        expect(described_class.rate_for(author: author, resource: article)).to eq record
-      end
-    end
-  end
-
-  context 'with scopeable' do
-    let!(:category) { create :category }
-
-    context 'when rate does not exist' do
-      it do
-        expect(described_class.rate_for(author: author, resource: article, scopeable: category)).to eq nil
-      end
-    end
-
-    context 'when rate exists' do
-      let!(:record) do
-        described_class.create(
-          author:       author,
-          extra_scopes: {},
-          metadata:     {},
-          resource:     article,
-          scopeable:    category,
-          value:        3
-        )
-      end
-
-      it 'returns the record' do
-        query = described_class.rate_for(author: author, resource: article, scopeable: category)
-
-        expect(query).to eq record
-      end
-    end
-  end
-
-  if ENV['CONFIG_ENABLED_WITH_EXTRA_SCOPES'] == 'true'
-    context 'with extra scopes' do
-      let!(:category) { create :category }
-
-      context 'when matches all attributes including the extra scopes' do
-        let!(:record) do
-          described_class.create(
-            author:       author,
-            extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_2' },
-            metadata:     {},
-            resource:     article,
-            scopeable:    category,
-            value:        1
-          )
-        end
-
-        it 'returns the record' do
-          result = described_class.rate_for(
-            author:       author,
-            extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_2' },
-            resource:     article,
-            scopeable:    category
-          )
-
-          expect(result).to eq record
-        end
-      end
-
-      context 'when matches all attributes but at least one extra scopes' do
-        before do
-          described_class.create(
-            author:       author,
-            extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_2' },
-            metadata:     {},
-            resource:     article,
-            scopeable:    category,
-            value:        1
-          )
-        end
-
-        it 'does not return the record' do
-          result = described_class.rate_for(
-            author:       author,
-            extra_scopes: { scope_1: 'scope_1', scope_2: 'scope_missing' },
-            resource:     article,
-            scopeable:    category
-          )
-
-          expect(result).to eq nil
-        end
-      end
-    end
-  end
-end

data/spec/models/rate_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Rating::Rate do
-  let!(:object) { build :rating_rate }
-
-  it { expect(object).to be_valid }
-
-  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 }
-  it { is_expected.to validate_presence_of :value }
-
-  it do
-    expect(subject).to validate_numericality_of(:value).is_less_than_or_equal_to(100).is_less_than_or_equal_to 100
-  end
-
-  it do
-    scopes = %i[author_type resource_id resource_type scopeable_id scopeable_type]
-    scopes += %i[scope_1 scope_2] if ENV['CONFIG_ENABLED_WITH_EXTRA_SCOPES'] == 'true'
-
-    expect(object).to validate_uniqueness_of(:author_id).scoped_to(scopes).case_insensitive
-  end
-end