solidus_reviews 1.0.0 → 1.1.0

data/spec/controllers/products_controller_spec.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Spree::ProductsController do
   [:avg_rating, :reviews_count].each do |attrib|
     it "should add #{attrib} to the set of allowed attributes" do
-      controller.permitted_product_attributes.should include(attrib)
+      expect(controller.permitted_product_attributes).to include(attrib)
     end
   end
-end
+end

data/spec/controllers/reviews_controller_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Spree::ReviewsController, type: :controller do
@@ -8,19 +10,24 @@ describe Spree::ReviewsController, type: :controller do
       review: { rating: 3,
                 name: 'Ryan Bigg',
                 title: 'Great Product',
-                review: 'Some big review text..' } }
+                review: 'Some big review text..',
+                images: [
+                  fixture_file_upload(File.new(Spree::Core::Engine.root + 'spec/fixtures/thinking-cat.jpg'))
+                ] }
+    }
   end
 
   before do
-    controller.stub :spree_current_user => user
-    controller.stub :spree_user_signed_in? => true
+    allow(controller).to receive(:spree_current_user).and_return(user)
+    allow(controller).to receive(:spree_user_signed_in?).and_return(true)
   end
 
   context '#index' do
     context 'for a product that does not exist' do
       it 'responds with a 404' do
-        spree_get :index, product_id: 'not_real'
-        response.status.should eq(404)
+        expect {
+          get :index, params: { product_id: 'not_real' }
+        }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
 
@@ -30,8 +37,8 @@ describe Spree::ReviewsController, type: :controller do
           create(:review, :approved, product: product),
           create(:review, :approved, product: product)
         ]
-        spree_get :index, product_id: product.slug
-        assigns[:approved_reviews].should =~ approved_reviews
+        get :index, params: { product_id: product.slug }
+        expect(assigns[:approved_reviews]).to match_array approved_reviews
       end
     end
   end
@@ -39,87 +46,107 @@ describe Spree::ReviewsController, type: :controller do
   context '#new' do
     context 'for a product that does not exist' do
       it 'responds with a 404' do
-        spree_get :new, product_id: 'not_real'
-        response.status.should eq(404)
+        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
-      controller.stub(:authorize!) { raise }
+      allow(controller).to receive(:authorize!).and_raise(RuntimeError)
+
       expect {
-        spree_post :new, product_id: product.slug
+        post :new, params: { product_id: product.slug }
         assert_match 'ryanbig', response.body
-      }.to raise_error
+      }.to raise_error RuntimeError
     end
 
     it 'render the new template' do
-      spree_get :new, product_id: product.slug
-      response.status.should eq(200)
-      response.should render_template(:new)
+      get :new, params: { product_id: product.slug }
+      expect(response.status).to eq(200)
+      expect(response).to render_template(:new)
     end
   end
 
   context '#create' do
-    before { controller.stub spree_current_user: user }
+    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
-        spree_post :create, product_id: 'not_real'
-        response.status.should eq(404)
+        expect {
+          post :create, params: { product_id: 'not_real' }
+        }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
 
     it 'creates a new review' do
       expect {
-        spree_post :create, review_params
+        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.stub(remote_ip: '127.0.0.1')
-      spree_post :create, review_params
-      assigns[:review].ip_address.should eq '127.0.0.1'
+      @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
-      controller.stub(:authorize!) { raise }
+      allow(controller).to receive(:authorize!).and_raise(RuntimeError)
+
       expect{
-        spree_post :create, review_params
-      }.to raise_error
+        post :create, params: review_params
+      }.to raise_error RuntimeError
     end
 
     it 'flashes the notice' do
-      spree_post :create, review_params
-      flash[:notice].should eq Spree.t(:review_successfully_submitted)
+      post :create, params: review_params
+      expect(flash[:notice]).to eq I18n.t('spree.review_successfully_submitted')
     end
 
     it 'redirects to product page' do
-      spree_post :create, review_params
-      response.should redirect_to spree.product_path(product)
+      post :create, params: review_params
+      expect(response).to redirect_to spree.product_path(product)
     end
 
     it 'removes all non-numbers from ratings param' do
-      spree_post :create, review_params
-      controller.params[:review][:rating].should eq '3'
+      post :create, params: review_params
+      expect(controller.params[:review][:rating]).to eq '3'
     end
 
     it 'sets the current spree user as reviews user' do
-      spree_post :create, review_params
-      review_params[:review].merge!(user_id: user.id)
+      post :create, params: review_params
+      review_params[:review][:user_id] = user.id
       assigns[:review][:user_id] = user.id
-      assigns[:review][:user_id].should eq 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
-        Spree::Review.any_instance.stub(:save).and_return(false)
-        spree_post :create, review_params
-        response.should render_template :new
+        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
-        spree_post :create, review_params.merge({review: {rating: 'not_a_number'}})
+        post :create, params: review_params.merge({ review: { rating: 'not_a_number' } })
         expect(Spree::Review.count).to eq 0
       end
     end
@@ -128,8 +155,8 @@ describe Spree::ReviewsController, type: :controller do
     context 'when config requires locale tracking:' do
       it 'sets the locale' do
         Spree::Reviews::Config.preferred_track_locale = true
-        spree_post :create, review_params
-        assigns[:review].locale.should eq I18n.locale.to_s
+        post :create, params: review_params
+        expect(assigns[:review].locale).to eq I18n.locale.to_s
       end
     end
   end

data/spec/controllers/spree/api/reviews_controller_spec.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Api::ReviewsController, type: :controller do
+  render_views
+
+  let!(:user) { create(:user) }
+  let!(:review) { create(:review, rating: 5) }
+  let!(:product) { review.product }
+
+  before do
+    user.generate_spree_api_key!
+    Array.new(3).each do
+      create(:review)
+    end
+  end
+
+  describe '#index' do
+    context 'when given a product_id' do
+      subject do
+        get :index, params: { product_id: product.id, token: user.spree_api_key, format: 'json' }
+        JSON.parse(response.body)
+      end
+
+      context 'there are no reviews for a product' do
+        it 'should return an empty array' do
+          expect(Spree::Review.count).to be >= 0
+          expect(subject["reviews"]).to be_empty
+        end
+      end
+
+      context 'there are reviews for the product and other products' do
+        it 'returns all approved reviews for the product' do
+          review.update(approved: true)
+          review.images << create(:image)
+          expect(Spree::Review.count).to be >= 2
+          expect(subject.size).to eq(2)
+          expect(subject["reviews"][0]["id"]).to eq(review.id)
+          expect(subject["reviews"][0]["images"].count).to eq(1)
+          expect(subject["avg_rating"]).to eq("5.0")
+        end
+      end
+    end
+
+    context 'when given a user_id' do
+      subject do
+        get :index, params: { user_id: user.id, token: user.spree_api_key, format: 'json' }
+        JSON.parse(response.body)
+      end
+
+      context 'there are no reviews for the user' do
+        it 'should return an empty array' do
+          expect(Spree::Review.count).to be >= 0
+          expect(subject["reviews"]).to be_empty
+        end
+      end
+
+      context 'there are reviews for user' do
+        before { review.update(user_id: user.id) }
+
+        it 'returns all reviews for the user' do
+          expect(Spree::Review.count).to be >= 2
+          expect(subject.size).to eq(2)
+          expect(subject["reviews"][0]["id"]).to eq(review.id)
+          expect(subject["avg_rating"]).to eq(nil)
+        end
+      end
+    end
+  end
+
+  describe '#show' do
+    subject do
+      get :show, params: { id: review.id, token: user.spree_api_key, format: 'json' }
+      JSON.parse(response.body)
+    end
+
+    context 'when it is the users review' do
+      before { review.update(user_id: user.id) }
+
+      it 'should return the review' do
+        expect(subject).not_to be_empty
+        expect(subject["product_id"]).to eq(product.id)
+        expect(subject["name"]).to eq(review[:name])
+        expect(subject["review"]).to eq(review[:review])
+        expect(subject["title"]).to eq(review[:title])
+        expect(subject["verified_purchaser"]).to eq(false)
+        expect(subject["images"]).to eq([])
+        expect(subject["feedback_reviews"]).to eq([])
+      end
+    end
+
+    context 'when it is not the users review' do
+      it 'should return with not authorized' do
+        expect(subject["error"]).not_to be_empty
+        expect(subject["error"]).to match(/not authorized/i)
+      end
+
+      context 'and it the review is approved' do
+        before { review.update(approved: true) }
+
+        it 'should return the review' do
+          expect(subject).not_to be_empty
+          expect(subject["product_id"]).to eq(product.id)
+          expect(subject["name"]).to eq(review[:name])
+          expect(subject["review"]).to eq(review[:review])
+          expect(subject["title"]).to eq(review[:title])
+          expect(subject["images"]).to eq([])
+          expect(subject["feedback_reviews"]).to eq([])
+        end
+      end
+    end
+  end
+
+  describe '#create' do
+    let(:review_params) do
+      {
+        "user_id": user.id,
+        "rating": "3 stars",
+        "title": "My title 2",
+        "name": "Full Name",
+        "review": "My review of the product"
+      }
+    end
+
+    subject do
+      params = { product_id: product.id, token: user.spree_api_key, format: 'json' }.merge(review_params)
+      post :create, params: params
+      JSON.parse(response.body)
+    end
+
+    context 'when user has already reviewed this product' do
+      before do
+        review.update(user_id: user.id)
+      end
+
+      it 'should return with a fail' do
+        expect(subject["error"]).not_to be_empty
+        expect(subject["error"]).to match(/invalid resource/i)
+      end
+    end
+
+    context 'when it is a users first review for the product' do
+      it 'should return success with review' do
+        expect(subject).not_to be_empty
+        expect(subject["product_id"]).to eq(product.id)
+        expect(subject["name"]).to eq(review_params[:name])
+        expect(subject["review"]).to eq(review_params[:review])
+        expect(subject["title"]).to eq(review_params[:title])
+        expect(subject["images"]).to eq([])
+        expect(subject["feedback_reviews"]).to eq([])
+      end
+    end
+  end
+
+  describe '#update' do
+    before { review.update(approved: true, user_id: user.id) }
+    let(:params) { { product_id: product.id, id: review.id, token: user.spree_api_key, format: 'json' }.merge(review_params) }
+
+    let(:review_params) do
+      {
+        "rating": "3 stars",
+        "title": "My title 2",
+        "name": "Full name",
+        "review": "My review of the product",
+      }
+    end
+
+    subject do
+      put :update, params: params
+      JSON.parse(response.body)
+    end
+
+    context 'when a user updates their own review' do
+      it 'should successfully update the review and set approved back to false' do
+        original = review
+        expect(original.approved?).to be true
+        expect(subject["id"]).to eq(original.id)
+        expect(subject["user_id"]).to eq(original.user_id)
+        expect(subject["product_id"]).to eq(original.product_id)
+        expect(subject["approved"]).to be false
+        expect(subject["images"]).to eq([])
+        expect(subject["feedback_reviews"]).to eq([])
+      end
+    end
+
+    context 'when a user updates another users review' do
+      let(:other_user) { create(:user) }
+      let(:params) { { product_id: product.id, id: review.id, token: other_user.spree_api_key, format: 'json' }.merge(review_params) }
+
+      before do
+        other_user.generate_spree_api_key!
+      end
+
+      it 'should return an error' do
+        expect(subject["error"]).not_to be_empty
+        expect(subject["error"]).to match(/not authorized/i)
+      end
+    end
+  end
+
+  describe '#destroy' do
+    before { review.update(approved: true, user_id: user.id) }
+    let(:params) { { product_id: product.id, id: review.id, token: user.spree_api_key, format: 'json' } }
+
+    subject do
+      delete :destroy, params: params
+      JSON.parse(response.body)
+    end
+
+    context "when a user destroys their own review" do
+      it 'should return the deleted review' do
+        expect(subject["id"]).to eq(review.id)
+        expect(subject["product_id"]).to eq(product.id)
+        expect(Spree::Review.find_by(id: review.id)).to be_falsey
+      end
+    end
+
+    context "when a user destroys another users review" do
+      let(:other_user) { create(:user) }
+      let(:params) { { product_id: product.id, id: review.id, token: other_user.spree_api_key, format: 'json' } }
+
+      before do
+        other_user.generate_spree_api_key!
+      end
+
+      it 'should return an error' do
+        expect(subject["error"]).not_to be_empty
+        expect(subject["error"]).to match(/not authorized/i)
+      end
+    end
+  end
+end

data/spec/features/admin_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.feature 'Review Admin' do
@@ -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