solidus_reviews 1.0.0 → 1.4.0

data/spec/controllers/spree/reviews_controller_spec.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::ReviewsController, type: :controller do
+  let(:user) { create(:user) }
+  let(:product) { create(:product) }
+  let(:review) { create(:review, :approved, product: product, user: user) }
+  let(:review_params) do
+    { product_id: product.slug,
+      review: { rating: 3,
+                name: 'Ryan Bigg',
+                title: 'Great Product',
+                review: 'Some big review text..',
+                images: [
+                  fixture_file_upload(File.new(Spree::Core::Engine.root + 'spec/fixtures/thinking-cat.jpg'))
+                ] } }
+  end
+
+  before do
+    allow(controller).to receive(:spree_current_user).and_return(user)
+    allow(controller).to receive(:spree_user_signed_in?).and_return(true)
+  end
+
+  describe '#index' do
+    context 'for a product that does not exist' do
+      it 'responds with a 404' do
+        expect {
+          get :index, params: { product_id: 'not_real' }
+        }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+    context 'for a valid product' do
+      it 'list approved reviews' do
+        approved_reviews = [
+          create(:review, :approved, product: product),
+          create(:review, :approved, product: product)
+        ]
+        get :index, params: { product_id: product.slug }
+        expect(assigns[:approved_reviews]).to match_array approved_reviews
+      end
+    end
+  end
+
+  describe '#new' do
+    context 'for a product that does not exist' do
+      it 'responds with a 404' do
+        expect {
+          get :new, params: { product_id: 'not_real' }
+        }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+    it 'fail if the user is not authorized to create a review' do
+      allow(controller).to receive(:authorize!).and_raise(RuntimeError)
+
+      expect {
+        post :new, params: { product_id: product.slug }
+        assert_match 'ryanbig', response.body
+      }.to raise_error RuntimeError
+    end
+
+    it 'render the new template' do
+      get :new, params: { product_id: product.slug }
+      expect(response.status).to eq(200)
+      expect(response).to render_template(:new)
+    end
+  end
+
+  describe '#edit' do
+
+    context 'for a product that does not exist' do
+      it 'responds with a 404' do
+        expect {
+          get :edit, params: { id: review.id, product_id: 'not_real' }
+        }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+    it 'fail if the user is not authorized to edit a review' do
+      allow(controller).to receive(:authorize!).and_raise(RuntimeError)
+
+      expect {
+        post :edit, params: { id: review.id, product_id: product.slug }
+        assert_match 'ryanbig', response.body
+      }.to raise_error RuntimeError
+    end
+
+    it 'render the edit template' do
+      get :edit, params: { id: review.id, product_id: product.slug }
+      expect(response.status).to eq(200)
+      expect(response).to render_template(:edit)
+    end
+
+    it 'doesn\'t allow another user to update a users review' do
+      other_user = create(:user)
+      allow(controller).to receive(:spree_current_user).and_return(other_user)
+      get :edit, params: {id: review.id, product_id: product.slug }
+      expect(response).to_not render_template(:edit)
+      expect(flash[:error]).to eq "Authorization Failure"
+    end
+  end
+
+  describe '#create' do
+    before { allow(controller).to receive(:spree_current_user).and_return(user) }
+
+    context 'for a product that does not exist' do
+      it 'responds with a 404' do
+        expect {
+          post :create, params: { product_id: 'not_real' }
+        }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+    it 'creates a new review' do
+      expect {
+        post :create, params: review_params
+      }.to change(Spree::Review, :count).by(1)
+    end
+
+    it 'creates a rating only review' do
+      review_params = {
+        product_id: product.slug,
+        review: { rating: 3 }
+      }
+
+      expect {
+        post :create, params: review_params
+      }.to change(Spree::Review, :count).by(1)
+    end
+
+    it 'sets the ip-address of the remote' do
+      @request.env['REMOTE_ADDR'] = '127.0.0.1'
+      post :create, params: review_params
+      expect(assigns[:review].ip_address).to eq '127.0.0.1'
+    end
+
+    it 'attaches the image' do
+      post :create, params: review_params
+      expect(assigns[:review].images).to be_present
+    end
+
+    it 'fails if the user is not authorized to create a review' do
+      allow(controller).to receive(:authorize!).and_raise(RuntimeError)
+
+      expect{
+        post :create, params: review_params
+      }.to raise_error RuntimeError
+    end
+
+    it 'flashes the notice' do
+      post :create, params: review_params
+      expect(flash[:notice]).to eq I18n.t('spree.review_successfully_submitted')
+    end
+
+    it 'redirects to product page' do
+      post :create, params: review_params
+      expect(response).to redirect_to spree.product_path(product)
+    end
+
+    it 'removes all non-numbers from ratings param' do
+      post :create, params: review_params
+      expect(controller.params[:review][:rating]).to eq '3'
+    end
+
+    it 'sets the current spree user as reviews user' do
+      post :create, params: review_params
+      review_params[:review][:user_id] = user.id
+      assigns[:review][:user_id] = user.id
+      expect(assigns[:review][:user_id]).to eq user.id
+    end
+
+    context 'with invalid params' do
+      it 'renders new when review.save fails' do
+        expect_any_instance_of(Spree::Review).to receive(:save).and_return(false)
+        post :create, params: review_params
+        expect(response).to render_template :new
+      end
+
+      it 'does not create a review' do
+        expect(Spree::Review.count).to eq 0
+        post :create, params: review_params.merge(review: { rating: 'not_a_number' })
+        expect(Spree::Review.count).to eq 0
+      end
+    end
+
+    # It always sets the locale so preference pointless
+    context 'when config requires locale tracking:' do
+      it 'sets the locale' do
+        stub_spree_preferences(Spree::Reviews::Config, track_locale: true)
+        post :create, params: review_params
+        expect(assigns[:review].locale).to eq I18n.locale.to_s
+      end
+    end
+  end
+
+  describe '#update' do
+    before {
+      allow(controller).to receive(:spree_current_user).and_return(user)
+      @review_params = { product_id: product.slug,
+        id: review.id,
+        review: { title: 'Amazing Product' } }
+    }
+
+    context 'for a product that does not exist' do
+      it 'responds with a 404' do
+        expect {
+          post :update, params: { id: review.id, product_id: 'not_real' }
+        }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+    it 'updates a review' do
+      post :update, params: @review_params
+      
+      expect(assigns[:review].title).to eq 'Amazing Product'
+      expect(assigns[:review].product).to eq product
+      expect(assigns[:review].user).to eq user
+    end
+
+    it 'updates a review to be a rating only review' do
+      post :update, params: {
+        product_id: product.slug,
+        id: review.id,
+        review: { title: '', review: '', rating: 5 }
+      }
+
+      expect(assigns[:review].title).to eq ''
+      expect(assigns[:review].review).to eq ''
+      expect(assigns[:review].rating).to eq 5
+    end
+
+    it 'updates the attached image' do
+      post :update, params: {
+        product_id: product.slug,
+        id: review.id,
+        review: {
+          images: [
+            fixture_file_upload(File.new(Spree::Core::Engine.root + 'spec/fixtures/thinking-cat.jpg')),
+          ] }
+      }
+      expect(assigns[:review].images.count).to eq 1
+    end
+
+    it 'fails if the user is not authorized to create a review' do
+      allow(controller).to receive(:authorize!).and_raise(RuntimeError)
+
+      expect{
+        post :update, params: @review_params
+      }.to raise_error RuntimeError
+    end
+
+    it 'flashes the notice' do
+      post :update, params: @review_params
+
+      expect(flash[:notice]).to eq I18n.t('spree.review_successfully_submitted')
+    end
+
+    it 'redirects to product page' do
+      post :update, params: @review_params
+      review.reload
+      review.valid?
+      expect(response).to redirect_to spree.product_path(product)
+    end
+
+    it 'removes all non-numbers from ratings param' do
+      @review_params[:review][:rating] = 5
+      post :update, params: @review_params
+      expect(controller.params[:review][:rating]).to eq '5'
+    end
+
+    it 'doesnt change the current spree user as reviews user' do
+      post :update, params: @review_params
+      expect(assigns[:review].user_id).to eq user.id
+    end
+
+    context 'with invalid params' do
+      it 'renders edit when review.save fails' do
+        expect_any_instance_of(Spree::Review).to receive(:update).and_return(false)
+        post :update, params: @review_params
+        expect(response).to render_template :edit
+      end
+
+      it 'does not update a review' do
+        original_rating = review.rating
+        original_title = review.title
+        @review_params[:review][:rating] = 'not_a_number'
+        @review_params[:review][:title] = true
+        post :update, params: @review_params
+        
+        review.reload
+        expect(review.rating).to eq original_rating
+        expect(review.title).to eq original_title
+      end
+    end
+  end
+end

data/spec/features/admin_spec.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-RSpec.feature 'Review Admin' do
+RSpec.describe 'Review Admin' do
   stub_authorization!
 
-  given!(:review) { create(:review) }
+  let!(:review) { create(:review) }
 
   context 'index' do
-    background do
+    before do
       visit spree.admin_reviews_path
     end
 
-    scenario 'list reviews' do
+    it 'list reviews' do
       expect(page).to have_text review.product.name
     end
 
-    scenario 'approve reviews' do
+    it 'approve reviews' do
       expect(review.approved).to be false
       within("tr#review_#{review.id}") do
         find('.approve').click
@@ -22,7 +24,7 @@ RSpec.feature 'Review Admin' do
       expect(review.reload.approved).to be true
     end
 
-    scenario 'edit reviews' do
+    it 'edit reviews' do
       expect(page).to have_text review.product.name
       within("tr#review_#{review.id}") do
         find('.edit').click
@@ -30,6 +32,7 @@ RSpec.feature 'Review Admin' do
 
       expect(page).to have_text 'Editing'
       expect(page).to have_text review.title
+      expect(page).to have_css('a', text: review.email)
     end
   end
 end

data/spec/features/reviews_spec.rb

@@ -1,78 +1,95 @@
+# 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) }
+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 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
-        Spree::Reviews::Config[:preview_size] = 2
+      before do
+        FactoryBot.create_list :review, 3, product: product_no_reviews, approved: true
+        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
-        expect(page).not_to have_text Spree.t(:write_your_own_review)
+      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
 
-      scenario 'can see create new review button' do
-        expect(page).to have_text Spree.t(:write_your_own_review)
+      context 'with unapproved content allowed' do
+        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
+
+        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
+
+      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
-        click_on Spree.t(:write_your_own_review)
+      it 'can create new review' do
+        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,28 +98,28 @@ 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
   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) }
-    
-    background do
+    let!(:user) { create(:user) }
+    let!(:review) { create(:review, :approved, :hide_identifier, review: 'review text', user: user) }
+
+    before do
       visit spree.product_path(review.product)
     end
 
-    scenario 'show anonymous review' do
-      expect(page).to have_text Spree.t(:anonymous)
+    it 'show anonymous review' do
+      expect(page).to have_text I18n.t('spree.anonymous')
       expect(page).to have_text 'review text'
     end
-
   end
 
   private