solidus_reviews 1.2.0 → 1.3.0

data/spec/features/reviews_spec.rb

@@ -2,90 +2,91 @@
 
 require 'spec_helper'
 
-feature 'Reviews', js: true do
-  given!(:someone) { create(:user, email: 'ryan@spree.com') }
-  given!(:review) { create(:review, :approved, user: someone) }
-  given!(:unapproved_review) { create(:review, product: review.product) }
+describe 'Reviews', js: true do
+  let!(:someone) { create(:user, email: 'ryan@spree.com') }
+  let!(:review) { create(:review, :approved, user: someone) }
+  let!(:unapproved_review) { create(:review, product: review.product) }
 
-  background do
-    Spree::Reviews::Config.include_unapproved_reviews = false
+  before do
+    stub_spree_preferences(Spree::Reviews::Config, include_unapproved_reviews: false)
   end
 
   context 'product with no review' do
-    given!(:product_no_reviews) { create(:product) }
-    scenario 'informs that no reviews has been written yet' do
+    let!(:product_no_reviews) { create(:product) }
+
+    it 'informs that no reviews has been written yet' do
       visit spree.product_path(product_no_reviews)
       expect(page).to have_text I18n.t('spree.no_reviews_available')
     end
 
     # Regression test for #103
     context "shows correct number of previews" do
-      background do
+      before do
         FactoryBot.create_list :review, 3, product: product_no_reviews, approved: true
-        Spree::Reviews::Config[:preview_size] = 2
+        stub_spree_preferences(Spree::Reviews::Config, preview_size: 2)
       end
 
-      scenario "displayed reviews are limited by the set preview size" do
+      it "displayed reviews are limited by the set preview size" do
         visit spree.product_path(product_no_reviews)
-        expect(page.all(".review").count).to eql(2)
+        expect(page.all(".review").count).to be(2)
       end
     end
   end
 
   context 'when anonymous user' do
-    background do
-      Spree::Reviews::Config.require_login = true
+    before do
+      stub_spree_preferences(Spree::Reviews::Config, require_login: true)
     end
 
     context 'visit product with review' do
-      background do
+      before do
         visit spree.product_path(review.product)
       end
 
-      scenario 'should see review title' do
+      it 'sees review title' do
         expect(page).to have_text review.title
       end
 
-      scenario 'can not create review' do
+      it 'can not create review' do
         expect(page).not_to have_text I18n.t('spree.write_your_own_review')
       end
     end
   end
 
   context 'when logged in user' do
-    given!(:user) { create(:user) }
+    let!(:user) { create(:user) }
 
-    background do
+    before do
       sign_in_as! user
     end
 
     context 'visit product with review' do
-      background do
+      before do
         visit spree.product_path(review.product)
       end
 
-      scenario 'can see review title' do
+      it 'can see review title' do
         expect(page).to have_text review.title
       end
 
       context 'with unapproved content allowed' do
-        background do
-          Spree::Reviews::Config[:include_unapproved_reviews] = true
-          Spree::Reviews::Config[:display_unapproved_reviews] = true
+        before do
+          stub_spree_preferences(Spree::Reviews::Config, include_unapproved_reviews: true)
+          stub_spree_preferences(Spree::Reviews::Config, display_unapproved_reviews: true)
           visit spree.product_path(review.product)
         end
 
-        scenario 'can see unapproved content when allowed' do
+        it 'can see unapproved content when allowed' do
           expect(unapproved_review.approved?).to eq(false)
           expect(page).to have_text unapproved_review.title
         end
       end
 
-      scenario 'can see create new review button' do
+      it 'can see create new review button' do
         expect(page).to have_text I18n.t('spree.write_your_own_review')
       end
 
-      scenario 'can create new review' do
+      it 'can create new review' do
         click_on I18n.t('spree.write_your_own_review')
 
         expect(page).to have_text I18n.t('spree.leave_us_a_review_for', name: review.product.name)
@@ -108,14 +109,14 @@ feature 'Reviews', js: true do
   end
 
   context 'visit product with review where show_identifier is false' do
-    given!(:user) { create(:user) }
-    given!(:review) { create(:review, :approved, :hide_identifier, review: 'review text', user: user) }
+    let!(:user) { create(:user) }
+    let!(:review) { create(:review, :approved, :hide_identifier, review: 'review text', user: user) }
 
-    background do
+    before do
       visit spree.product_path(review.product)
     end
 
-    scenario 'show anonymous review' do
+    it 'show anonymous review' do
       expect(page).to have_text I18n.t('spree.anonymous')
       expect(page).to have_text 'review text'
     end

data/spec/models/feedback_review_spec.rb

@@ -13,30 +13,30 @@ describe Spree::FeedbackReview do
     end
 
     it 'does not validate with a nil review' do
-      expect(build(:feedback_review, review: nil)).to_not be_valid
+      expect(build(:feedback_review, review: nil)).not_to be_valid
     end
 
     context 'rating' do
       it 'does not validate when no rating is specified' do
-        expect(build(:feedback_review, rating: nil)).to_not be_valid
+        expect(build(:feedback_review, rating: nil)).not_to be_valid
       end
 
       it 'does not validate when the rating is not a number' do
-        expect(build(:feedback_review, rating: 'not_a_number')).to_not be_valid
+        expect(build(:feedback_review, rating: 'not_a_number')).not_to be_valid
       end
 
       it 'does not validate when the rating is a float' do
-        expect(build(:feedback_review, rating: 2.718)).to_not be_valid
+        expect(build(:feedback_review, rating: 2.718)).not_to be_valid
       end
 
       it 'does not validate when the rating is less than 1' do
-        expect(build(:feedback_review, rating: 0)).to_not be_valid
-        expect(build(:feedback_review, rating: -5)).to_not be_valid
+        expect(build(:feedback_review, rating: 0)).not_to be_valid
+        expect(build(:feedback_review, rating: -5)).not_to be_valid
       end
 
       it 'does not validate when the rating is greater than 5' do
-        expect(build(:feedback_review, rating: 6)).to_not be_valid
-        expect(build(:feedback_review, rating: 8)).to_not be_valid
+        expect(build(:feedback_review, rating: 6)).not_to be_valid
+        expect(build(:feedback_review, rating: 8)).not_to be_valid
       end
 
       (1..5).each do |i|
@@ -54,11 +54,11 @@ describe Spree::FeedbackReview do
       let!(:feedback_review_3) { create(:feedback_review, created_at: 5.days.ago) }
 
       it 'properly runs most_recent_first queries' do
-        expect(Spree::FeedbackReview.most_recent_first.to_a).to eq([feedback_review_2, feedback_review_3, feedback_review_1])
+        expect(described_class.most_recent_first.to_a).to eq([feedback_review_2, feedback_review_3, feedback_review_1])
       end
 
       it 'defaults to most_recent_first queries' do
-        expect(Spree::FeedbackReview.all.to_a).to eq([feedback_review_2, feedback_review_3, feedback_review_1])
+        expect(described_class.all.to_a).to eq([feedback_review_2, feedback_review_3, feedback_review_1])
       end
     end
 
@@ -71,9 +71,9 @@ describe Spree::FeedbackReview do
       let!(:fr_feedback_review_1) { create(:feedback_review, locale: 'fr', created_at: 10.days.ago) }
 
       it 'properly runs localized queries' do
-        expect(Spree::FeedbackReview.localized('en').to_a).to eq([en_feedback_review_2, en_feedback_review_3, en_feedback_review_1])
-        expect(Spree::FeedbackReview.localized('es').to_a).to eq([es_feedback_review_1])
-        expect(Spree::FeedbackReview.localized('fr').to_a).to eq([fr_feedback_review_1])
+        expect(described_class.localized('en').to_a).to eq([en_feedback_review_2, en_feedback_review_3, en_feedback_review_1])
+        expect(described_class.localized('es').to_a).to eq([es_feedback_review_1])
+        expect(described_class.localized('fr').to_a).to eq([fr_feedback_review_1])
       end
     end
   end

data/spec/models/product_spec.rb

@@ -7,7 +7,7 @@ describe Spree::Product do
   it { is_expected.to respond_to(:reviews) }
   it { is_expected.to respond_to(:stars) }
 
-  context '#stars' do
+  describe '#stars' do
     let(:product) { build(:product) }
 
     it 'rounds' do
@@ -27,7 +27,7 @@ describe Spree::Product do
     end
   end
 
-  context '#recalculate_rating' do
+  describe '#recalculate_rating' do
     let!(:product) { create(:product) }
 
     context 'when there are approved reviews' do
@@ -36,11 +36,8 @@ describe Spree::Product do
       let!(:unapproved_review_1) { create(:review, product: product, approved: false, rating: 4) }
 
       context "including unapproved reviews" do
-        before(:all) do
-          Spree::Reviews::Config[:include_unapproved_reviews] = true
-        end
-        after(:all) do
-          Spree::Reviews::Config[:include_unapproved_reviews] = false
+        before do
+          stub_spree_preferences(Spree::Reviews::Config, include_unapproved_reviews: true)
         end
 
         it "updates the product average rating and ignores unapproved reviews" do
@@ -55,6 +52,10 @@ describe Spree::Product do
       end
 
       context "only approved reviews" do
+        before do
+          stub_spree_preferences(Spree::Reviews::Config, include_unapproved_reviews: false)
+        end
+
         it "updates the product average rating and ignores unapproved reviews" do
           product.avg_rating = 0
           product.reviews_count = 0
@@ -70,10 +71,12 @@ describe Spree::Product do
     context "without unapproved reviews" do
       let!(:unapproved_review_1) { create(:review, product: product, approved: false, rating: 4) }
 
+      before do
+        stub_spree_preferences(Spree::Reviews::Config, include_unapproved_reviews: false)
+      end
+
       it "updates the product average rating and ignores unapproved reviews" do
-        product.avg_rating = 3
-        product.reviews_count = 20
-        product.save!
+        product.update_columns(avg_rating: 3, reviews_count: 20)
 
         product.recalculate_rating
         expect(product.avg_rating).to eq(0)

data/spec/models/review_spec.rb

@@ -18,25 +18,25 @@ describe Spree::Review do
 
     context 'rating' do
       it 'does not validate when no rating is specified' do
-        expect(build(:review, rating: nil)).to_not be_valid
+        expect(build(:review, rating: nil)).not_to be_valid
       end
 
       it 'does not validate when the rating is not a number' do
-        expect(build(:review, rating: 'not_a_number')).to_not be_valid
+        expect(build(:review, rating: 'not_a_number')).not_to be_valid
       end
 
       it 'does not validate when the rating is a float' do
-        expect(build(:review, rating: 2.718)).to_not be_valid
+        expect(build(:review, rating: 2.718)).not_to be_valid
       end
 
       it 'does not validate when the rating is less than 1' do
-        expect(build(:review, rating: 0)).to_not be_valid
-        expect(build(:review, rating: -5)).to_not be_valid
+        expect(build(:review, rating: 0)).not_to be_valid
+        expect(build(:review, rating: -5)).not_to be_valid
       end
 
       it 'does not validate when the rating is greater than 5' do
-        expect(build(:review, rating: 6)).to_not be_valid
-        expect(build(:review, rating: 8)).to_not be_valid
+        expect(build(:review, rating: 6)).not_to be_valid
+        expect(build(:review, rating: 8)).not_to be_valid
       end
 
       (1..5).each do |i|
@@ -47,7 +47,7 @@ describe Spree::Review do
     end
 
     context 'review body' do
-      it 'should be valid without a body' do
+      it 'is valid without a body' do
         expect(build(:review, review: nil)).to be_valid
       end
     end
@@ -60,11 +60,11 @@ describe Spree::Review do
       let!(:review_3) { create(:review, created_at: 5.days.ago) }
 
       it 'properly runs most_recent_first queries' do
-        expect(Spree::Review.most_recent_first.to_a).to eq([review_2, review_3, review_1])
+        expect(described_class.most_recent_first.to_a).to eq([review_2, review_3, review_1])
       end
 
       it 'defaults to most_recent_first queries' do
-        expect(Spree::Review.all.to_a).to eq([review_2, review_3, review_1])
+        expect(described_class.all.to_a).to eq([review_2, review_3, review_1])
       end
     end
 
@@ -72,19 +72,14 @@ describe Spree::Review do
       let!(:review_1) { create(:review, created_at: 10.days.ago) }
       let!(:review_2) { create(:review, created_at: 2.days.ago) }
       let!(:review_3) { create(:review, created_at: 5.days.ago) }
-      let!(:review_4) { create(:review, created_at: 1.days.ago) }
-
-      before do
-        reset_spree_preferences
-        Spree::Reviews::Config.preference_store = Spree::Reviews::Config.default_preferences
-      end
+      let!(:review_4) { create(:review, created_at: 1.day.ago) }
 
       it 'properly runs oldest_first queries' do
-        expect(Spree::Review.oldest_first.to_a).to eq([review_1, review_3, review_2, review_4])
+        expect(described_class.oldest_first.to_a).to eq([review_1, review_3, review_2, review_4])
       end
 
       it 'uses oldest_first for preview' do
-        expect(Spree::Review.preview.to_a).to eq([review_1, review_3, review_2])
+        expect(described_class.preview.to_a).to eq([review_1, review_3, review_2])
       end
     end
 
@@ -97,9 +92,9 @@ describe Spree::Review do
       let!(:fr_review_1) { create(:review, locale: 'fr', created_at: 10.days.ago) }
 
       it 'properly runs localized queries' do
-        expect(Spree::Review.localized('en').to_a).to eq([en_review_2, en_review_3, en_review_1])
-        expect(Spree::Review.localized('es').to_a).to eq([es_review_1])
-        expect(Spree::Review.localized('fr').to_a).to eq([fr_review_1])
+        expect(described_class.localized('en').to_a).to eq([en_review_2, en_review_3, en_review_1])
+        expect(described_class.localized('es').to_a).to eq([es_review_1])
+        expect(described_class.localized('fr').to_a).to eq([fr_review_1])
       end
     end
 
@@ -109,26 +104,26 @@ describe Spree::Review do
       let!(:approved_review_3) { create(:review, approved: true, created_at: 5.days.ago) }
 
       let!(:unapproved_review_1) { create(:review, approved: false, created_at: 7.days.ago) }
-      let!(:unapproved_review_2) { create(:review, approved: false, created_at: 1.days.ago) }
+      let!(:unapproved_review_2) { create(:review, approved: false, created_at: 1.day.ago) }
 
       it 'properly runs approved and unapproved queries' do
-        expect(Spree::Review.approved.to_a).to eq([approved_review_2, approved_review_3, approved_review_1])
-        expect(Spree::Review.not_approved.to_a).to eq([unapproved_review_2, unapproved_review_1])
-
-        Spree::Reviews::Config[:include_unapproved_reviews] = true
-        expect(Spree::Review.default_approval_filter.to_a).to eq([unapproved_review_2,
-                                                                  approved_review_2,
-                                                                  approved_review_3,
-                                                                  unapproved_review_1,
-                                                                  approved_review_1])
-
-        Spree::Reviews::Config[:include_unapproved_reviews] = false
-        expect(Spree::Review.default_approval_filter.to_a).to eq([approved_review_2, approved_review_3, approved_review_1])
+        expect(described_class.approved.to_a).to eq([approved_review_2, approved_review_3, approved_review_1])
+        expect(described_class.not_approved.to_a).to eq([unapproved_review_2, unapproved_review_1])
+
+        stub_spree_preferences(Spree::Reviews::Config, include_unapproved_reviews: true)
+        expect(described_class.default_approval_filter.to_a).to eq([unapproved_review_2,
+                                                                    approved_review_2,
+                                                                    approved_review_3,
+                                                                    unapproved_review_1,
+                                                                    approved_review_1])
+
+        stub_spree_preferences(Spree::Reviews::Config, include_unapproved_reviews: false)
+        expect(described_class.default_approval_filter.to_a).to eq([approved_review_2, approved_review_3, approved_review_1])
       end
     end
   end
 
-  context '#recalculate_product_rating' do
+  describe '#recalculate_product_rating' do
     let(:product) { create(:product) }
     let!(:review) { create(:review, product: product) }
 
@@ -141,7 +136,7 @@ describe Spree::Review do
     end
 
     it 'if not approved' do
-      expect(review).to_not receive(:recalculate_product_rating)
+      expect(review).not_to receive(:recalculate_product_rating)
       review.save!
     end
 
@@ -152,8 +147,9 @@ describe Spree::Review do
     end
   end
 
-  context '#feedback_stars' do
+  describe '#feedback_stars' do
     let!(:review) { create(:review) }
+
     before do
       3.times do |i|
         f = Spree::FeedbackReview.new
@@ -163,12 +159,12 @@ describe Spree::Review do
       end
     end
 
-    it 'should return the average rating from feedback reviews' do
+    it 'returns the average rating from feedback reviews' do
       expect(review.feedback_stars).to eq 2
     end
   end
 
-  context '#email' do
+  describe '#email' do
     it 'returns email from user' do
       user = build(:user, email: 'john@smith.com')
       review = build(:review, user: user)
@@ -191,7 +187,7 @@ describe Spree::Review do
     end
   end
 
-  context "#verify_purchaser" do
+  describe "#verify_purchaser" do
     let(:order) { create(:completed_order_with_totals) }
     let(:product) { order.products.first }
     let(:user) { order.user }

data/spec/models/reviews_ability_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 require "cancan/matchers"
 
 describe Spree::ReviewsAbility do
-  context '.allow_anonymous_reviews?' do
-    it 'should depend on Spree::Reviews::Config[:require_login]' do
-      Spree::Reviews::Config[:require_login] = false
-      expect(Spree::ReviewsAbility.allow_anonymous_reviews?).to be true
-      Spree::Reviews::Config[:require_login] = true
-      expect(Spree::ReviewsAbility.allow_anonymous_reviews?).to be false
+  describe '.allow_anonymous_reviews?' do
+    it 'depends on Spree::Reviews::Config[:require_login]' do
+      stub_spree_preferences(Spree::Reviews::Config, require_login: false)
+      expect(described_class.allow_anonymous_reviews?).to be true
+      stub_spree_preferences(Spree::Reviews::Config, require_login: true)
+      expect(described_class.allow_anonymous_reviews?).to be false
     end
   end
 
@@ -20,28 +20,28 @@ describe Spree::ReviewsAbility do
 
     context 'when anonymous reviews are allowed' do
       before do
-        Spree::Reviews::Config[:require_login] = false
+        stub_spree_preferences(Spree::Reviews::Config, require_login: false)
       end
 
       it 'lets anyone create a review or feedback review' do
         [user_without_email, user_with_email].each do |u|
-          expect(Spree::ReviewsAbility.new(u)).to be_able_to(:create, Spree::Review.new)
-          expect(Spree::ReviewsAbility.new(u)).to be_able_to(:create, Spree::FeedbackReview.new)
+          expect(described_class.new(u)).to be_able_to(:create, Spree::Review.new)
+          expect(described_class.new(u)).to be_able_to(:create, Spree::FeedbackReview.new)
         end
       end
     end
 
     context 'when anonymous reviews are not allowed' do
       before do
-        Spree::Reviews::Config[:require_login] = true
+        stub_spree_preferences(Spree::Reviews::Config, require_login: true)
       end
 
       it 'only allows users with an email to create a review or feedback review' do
-        expect(Spree::ReviewsAbility.new(user_without_email)).to_not be_able_to(:create, Spree::Review.new)
-        expect(Spree::ReviewsAbility.new(user_without_email)).to_not be_able_to(:create, Spree::FeedbackReview.new)
+        expect(described_class.new(user_without_email)).not_to be_able_to(:create, Spree::Review.new)
+        expect(described_class.new(user_without_email)).not_to be_able_to(:create, Spree::FeedbackReview.new)
 
-        expect(Spree::ReviewsAbility.new(user_with_email)).to be_able_to(:create, Spree::Review.new)
-        expect(Spree::ReviewsAbility.new(user_with_email)).to be_able_to(:create, Spree::FeedbackReview.new)
+        expect(described_class.new(user_with_email)).to be_able_to(:create, Spree::Review.new)
+        expect(described_class.new(user_with_email)).to be_able_to(:create, Spree::FeedbackReview.new)
       end
     end
   end