solidus_reviews 1.0.0 → 1.4.0

data/spec/helpers/review_helper_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Spree::ReviewsHelper do
@@ -11,7 +13,6 @@ describe Spree::ReviewsHelper do
     specify do
       matches = mk_stars(2).scan(/unlit/)
       expect(matches.length).to eq 3
-
     end
   end
 
@@ -25,4 +26,4 @@ describe Spree::ReviewsHelper do
       expect(txt_stars(3, false)).to eq('3')
     end
   end
-end
+end

data/spec/models/feedback_review_spec.rb

@@ -1,45 +1,47 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Spree::FeedbackReview do
   context 'validations' do
     it 'validates by default' do
-      build(:feedback_review).should be_valid
+      expect(build(:feedback_review)).to be_valid
     end
 
     it 'validates with a nil user' do
-      build(:feedback_review, user: nil).should be_valid
+      expect(build(:feedback_review, user: nil)).to be_valid
     end
 
     it 'does not validate with a nil review' do
-      build(:feedback_review, review: nil).should_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
-        build(:feedback_review, rating: nil).should_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
-        build(:feedback_review, rating: 'not_a_number').should_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
-        build(:feedback_review, rating: 2.718).should_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
-        build(:feedback_review, rating: 0).should_not be_valid
-        build(:feedback_review, rating: -5).should_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
-        build(:feedback_review, rating: 6).should_not be_valid
-        build(:feedback_review, rating: 8).should_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|
         it "validates when the rating is #{i}" do
-          build(:feedback_review, rating: i).should be_valid
+          expect(build(:feedback_review, rating: i)).to be_valid
         end
       end
     end
@@ -52,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
-        Spree::FeedbackReview.most_recent_first.to_a.should 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
-        Spree::FeedbackReview.all.to_a.should 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
 
@@ -69,10 +71,10 @@ 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
-        Spree::FeedbackReview.localized('en').to_a.should eq([en_feedback_review_2, en_feedback_review_3, en_feedback_review_1])
-        Spree::FeedbackReview.localized('es').to_a.should eq([es_feedback_review_1])
-        Spree::FeedbackReview.localized('fr').to_a.should 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
-end
+end

data/spec/models/product_spec.rb

@@ -1,31 +1,33 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Spree::Product do
-  it { should respond_to(:avg_rating) }
-  it { should respond_to(:reviews) }
-  it { should respond_to(:stars) }
+  it { is_expected.to respond_to(:avg_rating) }
+  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
-      product.stub(:avg_rating).and_return(3.7)
+      allow(product).to receive(:avg_rating).and_return(3.7)
       expect(product.stars).to eq(4)
 
-      product.stub(:avg_rating).and_return(2.3)
+      allow(product).to receive(:avg_rating).and_return(2.3)
       expect(product.stars).to eq(2)
     end
 
-
     it 'handles a nil value' do
-      product.stub(:avg_rating).and_return(nil)
+      allow(product).to receive(:avg_rating).and_return(nil)
+
       expect {
         expect(product.stars).to eq(0)
       }.not_to raise_error
     end
   end
 
-  context '#recalculate_rating' do
+  describe '#recalculate_rating' do
     let!(:product) { create(:product) }
 
     context 'when there are approved reviews' do
@@ -33,30 +35,53 @@ describe Spree::Product do
       let!(:approved_review_2) { create(:review, product: product, approved: true, rating: 5) }
       let!(:unapproved_review_1) { create(:review, product: product, approved: false, rating: 4) }
 
-      it "updates the product average rating and ignores unapproved reviews" do
-        product.avg_rating = 0
-        product.reviews_count = 0
-        product.save!
+      context "including unapproved reviews" do
+        before do
+          stub_spree_preferences(Spree::Reviews::Config, include_unapproved_reviews: true)
+        end
 
-        product.recalculate_rating
-        product.avg_rating.should eq(4.5)
-        product.reviews_count.should eq(2)
+        it "updates the product average rating and ignores unapproved reviews" do
+          product.avg_rating = 0
+          product.reviews_count = 0
+          product.save!
+
+          product.recalculate_rating
+          expect(product.avg_rating).to eq(4.3)
+          expect(product.reviews_count).to eq(3)
+        end
+      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
+          product.save!
+
+          product.recalculate_rating
+          expect(product.avg_rating).to eq(4.5)
+          expect(product.reviews_count).to eq(2)
+        end
       end
     end
 
-    context 'when no approved reviews' 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
-        product.avg_rating.should eq(0)
-        product.reviews_count.should eq(0)
+        expect(product.avg_rating).to eq(0)
+        expect(product.reviews_count).to eq(0)
       end
     end
-
   end
-end
+end

data/spec/models/review_spec.rb

@@ -1,53 +1,54 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Spree::Review do
-
   context 'validations' do
     it 'validates by default' do
-      build(:review).should be_valid
+      expect(build(:review)).to be_valid
     end
 
     it 'validates with a nil user' do
-      build(:review, user: nil).should be_valid
+      expect(build(:review, user: nil)).to be_valid
     end
 
-    it 'does not validate with a nil review' do
-      build(:review, review: nil).should_not be_valid
+    it 'validates with a nil review' do
+      expect(build(:review, review: nil)).to be_valid
     end
 
     context 'rating' do
       it 'does not validate when no rating is specified' do
-        build(:review, rating: nil).should_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
-        build(:review, rating: 'not_a_number').should_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
-        build(:review, rating: 2.718).should_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
-        build(:review, rating: 0).should_not be_valid
-        build(:review, rating: -5).should_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
-        build(:review, rating: 6).should_not be_valid
-        build(:review, rating: 8).should_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|
-        it "validates when the rating is #{i}" do
-          build(:review, rating: i).should be_valid
+        it 'validates when the rating is #{i}' do
+          expect(build(:review, rating: i)).to be_valid
         end
       end
     end
 
     context 'review body' do
-      it 'should not be valid without a body' do
-        build(:review, review: nil).should_not be_valid
+      it 'is valid without a body' do
+        expect(build(:review, review: nil)).to be_valid
       end
     end
   end
@@ -59,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
-        Spree::Review.most_recent_first.to_a.should 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
-        Spree::Review.all.to_a.should eq([review_2, review_3, review_1])
+        expect(described_class.all.to_a).to eq([review_2, review_3, review_1])
       end
     end
 
@@ -71,18 +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
-      end
+      let!(:review_4) { create(:review, created_at: 1.day.ago) }
 
       it 'properly runs oldest_first queries' do
-        Spree::Review.oldest_first.to_a.should 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
-        Spree::Review.preview.to_a.should eq([review_1, review_3])
+        expect(described_class.preview.to_a).to eq([review_1, review_3, review_2])
       end
     end
 
@@ -95,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
-        Spree::Review.localized('en').to_a.should eq([en_review_2, en_review_3, en_review_1])
-        Spree::Review.localized('es').to_a.should eq([es_review_1])
-        Spree::Review.localized('fr').to_a.should 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
 
@@ -107,62 +104,146 @@ 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
-        Spree::Review.approved.to_a.should eq([approved_review_2, approved_review_3, approved_review_1])
-        Spree::Review.not_approved.to_a.should eq([unapproved_review_2, unapproved_review_1])
-
-        Spree::Reviews::Config[:include_unapproved_reviews] = true
-        Spree::Review.default_approval_filter.to_a.should eq([unapproved_review_2,
-                                                              approved_review_2,
-                                                              approved_review_3,
-                                                              unapproved_review_1,
-                                                              approved_review_1])
-
-        Spree::Reviews::Config[:include_unapproved_reviews] = false
-        Spree::Review.default_approval_filter.to_a.should 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) }
 
     before { product.reviews << review }
 
-    it "if approved" do
-      review.should_receive(:recalculate_product_rating)
+    it 'if approved' do
+      expect(review).to receive(:recalculate_product_rating)
       review.approved = true
       review.save!
     end
 
-    it "if not approved" do
-      review.should_not_receive(:recalculate_product_rating)
+    it 'if not approved' do
+      expect(review).not_to receive(:recalculate_product_rating)
       review.save!
     end
 
-    it "updates the product average rating" do
-      review.product.should_receive(:recalculate_rating)
+    it 'updates the product average rating' do
+      expect(review.product).to receive(:recalculate_rating)
       review.approved = true
       review.save!
     end
   end
 
-  context "#feedback_stars" do
+  describe '#feedback_stars' do
     let!(:review) { create(:review) }
+
     before do
       3.times do |i|
         f = Spree::FeedbackReview.new
         f.review = review
-        f.rating = (i+1)
+        f.rating = (i + 1)
         f.save
       end
     end
 
-    it "should return the average rating from feedback reviews" do
-      review.feedback_stars.should == 2
+    it 'returns the average rating from feedback reviews' do
+      expect(review.feedback_stars).to eq 2
+    end
+  end
+
+  describe '#email' do
+    it 'returns email from user' do
+      user = build(:user, email: 'john@smith.com')
+      review = build(:review, user: user)
+      expect(review.email).to eq('john@smith.com')
+    end
+  end
+
+  context 'images' do
+    it 'supports images' do
+      review = build(:review, images: [build(:image)])
+      expect(review.images).not_to eq(nil)
+    end
+
+    it 'respects order' do
+      image_1 = build(:image, position: 2)
+      image_2 = build(:image, position: 1)
+      review = create(:review, images: [image_1, image_2])
+      review.reload
+      expect(review.images.first).to eq(image_2)
+    end
+  end
+
+  describe "#verify_purchaser" do
+    let(:order) { create(:completed_order_with_totals) }
+    let(:product) { order.products.first }
+    let(:user) { order.user }
+    let(:review) { build(:review, user: user, product: product) }
+
+    it "returns true if the user has purchased the product" do
+      expect(review.verified_purchaser).to eq(false)
+      review.verify_purchaser
+      expect(review.verified_purchaser).to eq(true)
+    end
+
+    it "returns false if the user has not purchased the product" do
+      review.user = create(:user)
+      expect(review.verified_purchaser).to eq(false)
+      review.verify_purchaser
+      expect(review.verified_purchaser).to eq(false)
+    end
+
+    it "returns nothing if there is no user_id or product_id" do
+      review.product_id = nil
+      expect(review.verified_purchaser).to eq(false)
+      review.verify_purchaser
+      expect(review.verified_purchaser).to eq(false)
+
+      review.product_id = product.id
+      review.user_id = nil
+      expect(review.verified_purchaser).to eq(false)
+      review.verify_purchaser
+      expect(review.verified_purchaser).to eq(false)
+    end
+  end
+
+  describe "#approve_review" do
+    let(:order) { create(:completed_order_with_totals) }
+    let(:product) { order.products.first }
+    let(:user) { order.user }
+    let(:review) { build(:review, title: '', review: '', user: user, product: product) }
+
+    it "auto approves star only review" do
+      stub_spree_preferences(Spree::Reviews::Config, approve_star_only: true)
+
+      expect(review.approved).to eq(false)
+      review.approve_review
+      expect(review.approved).to eq(true)
+    end
+
+    it "auto approves star only review for verified purchaser" do
+      stub_spree_preferences(Spree::Reviews::Config, approve_star_only_for_verified_purchaser: true)
+
+      expect(review.verified_purchaser).to eq(false)
+      expect(review.approved).to eq(false)
+      review.verify_purchaser
+      expect(review.verified_purchaser).to eq(true)
+      expect(review.approved).to eq(false)
+      review.approve_review
+      expect(review.approved).to eq(true)
     end
   end
 end