solidus_reviews 1.0.0 → 1.1.0

data/spec/features/reviews_spec.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 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) }
 
   background do
     Spree::Reviews::Config.include_unapproved_reviews = false
@@ -12,13 +15,13 @@ feature 'Reviews', js: true do
     given!(:product_no_reviews) { create(:product) }
     scenario 'informs that no reviews has been written yet' do
       visit spree.product_path(product_no_reviews)
-      expect(page).to have_text Spree.t(:no_reviews_available)
+      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
-        FactoryGirl.create_list :review, 3, product: product_no_reviews, approved: true
+        FactoryBot.create_list :review, 3, product: product_no_reviews, approved: true
         Spree::Reviews::Config[:preview_size] = 2
       end
 
@@ -44,7 +47,7 @@ feature 'Reviews', js: true do
       end
 
       scenario 'can not create review' do
-        expect(page).not_to have_text Spree.t(:write_your_own_review)
+        expect(page).not_to have_text I18n.t('spree.write_your_own_review')
       end
     end
   end
@@ -65,14 +68,27 @@ feature 'Reviews', js: true 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
+          visit spree.product_path(review.product)
+        end
+
+        scenario '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
-        expect(page).to have_text Spree.t(:write_your_own_review)
+        expect(page).to have_text I18n.t('spree.write_your_own_review')
       end
 
       scenario 'can create new review' do
-        click_on Spree.t(:write_your_own_review)
+        click_on I18n.t('spree.write_your_own_review')
 
-        expect(page).to have_text Spree.t(:leave_us_a_review_for, name: review.product.name)
+        expect(page).to have_text I18n.t('spree.leave_us_a_review_for', name: review.product.name)
         expect(page).not_to have_text 'Show Identifier'
 
         within '#new_review' do
@@ -81,10 +97,11 @@ feature 'Reviews', js: true do
           fill_in 'review_name', with: user.email
           fill_in 'review_title', with: 'Great product!'
           fill_in 'review_review', with: 'Some big review text..'
+          attach_file 'review_images', Spree::Core::Engine.root + 'spec/fixtures/thinking-cat.jpg'
           click_on 'Submit your review'
         end
-        
-        expect(page.find('.flash.notice', text: Spree.t(:review_successfully_submitted))).to be_truthy
+
+        expect(page.find('.flash.notice', text: I18n.t('spree.review_successfully_submitted'))).to be_truthy
         expect(page).not_to have_text 'Some big review text..'
       end
     end
@@ -93,16 +110,15 @@ feature 'Reviews', js: true do
   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) }
-    
+
     background do
       visit spree.product_path(review.product)
     end
 
     scenario 'show anonymous review' do
-      expect(page).to have_text Spree.t(:anonymous)
+      expect(page).to have_text I18n.t('spree.anonymous')
       expect(page).to have_text 'review text'
     end
-
   end
 
   private

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)).to_not 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)).to_not 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')).to_not 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)).to_not 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)).to_not be_valid
+        expect(build(:feedback_review, rating: -5)).to_not 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)).to_not be_valid
+        expect(build(:feedback_review, rating: 8)).to_not 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(Spree::FeedbackReview.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(Spree::FeedbackReview.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(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])
       end
     end
   end
-end
+end

data/spec/models/product_spec.rb

@@ -1,24 +1,26 @@
+# 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
     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
@@ -33,18 +35,39 @@ 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(:all) do
+          Spree::Reviews::Config[:include_unapproved_reviews] = true
+        end
+        after(:all) do
+          Spree::Reviews::Config[:include_unapproved_reviews] = false
+        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
+        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) }
 
       it "updates the product average rating and ignores unapproved reviews" do
@@ -53,10 +76,9 @@ describe Spree::Product do
         product.save!
 
         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)).to_not 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')).to_not 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)).to_not 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)).to_not be_valid
+        expect(build(:review, rating: -5)).to_not 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)).to_not be_valid
+        expect(build(:review, rating: 8)).to_not 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 'should be 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(Spree::Review.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(Spree::Review.all.to_a).to eq([review_2, review_3, review_1])
       end
     end
 
@@ -75,14 +76,15 @@ describe Spree::Review do
 
       before do
         reset_spree_preferences
+        Spree::Reviews::Config.preference_store = Spree::Reviews::Config.default_preferences
       end
 
       it 'properly runs oldest_first queries' do
-        Spree::Review.oldest_first.to_a.should eq([review_1, review_3, review_2, review_4])
+        expect(Spree::Review.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(Spree::Review.preview.to_a).to eq([review_1, review_3, review_2])
       end
     end
 
@@ -95,9 +97,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(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])
       end
     end
 
@@ -110,59 +112,115 @@ describe Spree::Review do
       let!(:unapproved_review_2) { create(:review, approved: false, created_at: 1.days.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])
+        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
-        Spree::Review.default_approval_filter.to_a.should eq([unapproved_review_2,
-                                                              approved_review_2,
-                                                              approved_review_3,
-                                                              unapproved_review_1,
-                                                              approved_review_1])
+        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
-        Spree::Review.default_approval_filter.to_a.should eq([approved_review_2, approved_review_3, approved_review_1])
+        expect(Spree::Review.default_approval_filter.to_a).to eq([approved_review_2, approved_review_3, approved_review_1])
       end
     end
   end
 
-  context "#recalculate_product_rating" do
+  context '#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).to_not 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
+  context '#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 'should return the average rating from feedback reviews' do
+      expect(review.feedback_stars).to eq 2
+    end
+  end
+
+  context '#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
+
+  context "#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
 end