solidus_reviews 1.0.0 → 1.4.0

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Api::FeedbackReviewsController, type: :controller do
+  render_views
+
+  let!(:user) { create(:user) }
+  let!(:review) { create(:review) }
+  let!(:feedback_review) { create(:feedback_review, review: review) }
+
+  before do
+    user.generate_spree_api_key!
+  end
+
+  describe '#create' do
+    subject do
+      params = { review_id: review.id, token: user.spree_api_key, format: 'json' }.merge(feedback_review_params)
+      post :create, params: params
+      JSON.parse(response.body)
+    end
+
+    let(:feedback_review_params) do
+      {
+        "feedback_review": {
+          "rating": "5",
+          "comment": "I agree with what you said"
+        }
+      }
+    end
+
+    context 'when user has already left feedback on a reviewed this product' do
+      before do
+        feedback_review.update(user_id: user.id)
+      end
+
+      it 'returns 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 feedback for a review' do
+      it 'returns success with feedback' do
+        expect(subject).not_to be_empty
+        expect(subject["review_id"]).to eq(review.id)
+        expect(subject["rating"]).to eq(5)
+        expect(subject["comment"]).to eq("I agree with what you said")
+      end
+
+      it 'updates the review' do
+        expect(review).to receive(:touch)
+        feedback = create(:feedback_review, review: review)
+        feedback.save!
+      end
+    end
+  end
+
+  describe '#update' do
+    subject do
+      put :update, params: params
+      JSON.parse(response.body)
+    end
+
+    before { feedback_review.update(user_id: user.id) }
+
+    let(:params) { { review_id: review.id, id: feedback_review.id, token: user.spree_api_key, format: 'json' }.merge(feedback_review_params) }
+
+    let(:feedback_review_params) do
+      {
+        "feedback_review": {
+          "rating": "1",
+          "comment": "Actually I don't agree"
+        }
+      }
+    end
+
+    context 'when a user updates their own feedback for a review' do
+      it 'successfully updates their feedback' do
+        original = feedback_review
+        expect(subject["id"]).to eq(original.id)
+        expect(subject["user_id"]).to eq(original.user_id)
+        expect(subject["review_id"]).to eq(original.review_id)
+        expect(subject["rating"]).to eq(1)
+        expect(subject["comment"]).to eq("Actually I don't agree")
+      end
+    end
+
+    context 'when a user updates another users review' do
+      let(:other_user) { create(:user) }
+      let(:params) { { review_id: review.id, id: feedback_review.id, token: other_user.spree_api_key, format: 'json' }.merge(feedback_review_params) }
+
+      before do
+        other_user.generate_spree_api_key!
+      end
+
+      it 'returns an error' do
+        expect(subject["error"]).not_to be_empty
+        expect(subject["error"]).to match(/not authorized/i)
+      end
+    end
+  end
+
+  describe '#destroy' do
+    subject do
+      delete :destroy, params: params
+      JSON.parse(response.body)
+    end
+
+    before { feedback_review.update(user_id: user.id) }
+
+    let(:params) { { review_id: review.id, id: feedback_review.id, token: user.spree_api_key, format: 'json' } }
+
+    context "when a user destroys their own feedback" do
+      it 'returns the deleted feedback' do
+        expect(subject["id"]).to eq(feedback_review.id)
+        expect(subject["review_id"]).to eq(review.id)
+        expect(Spree::FeedbackReview.find_by(id: feedback_review.id)).to be_falsey
+      end
+    end
+
+    context "when a user destroys another users feedback" do
+      let(:other_user) { create(:user) }
+      let(:params) { { review_id: review.id, id: feedback_review.id, token: other_user.spree_api_key, format: 'json' } }
+
+      before do
+        other_user.generate_spree_api_key!
+      end
+
+      it 'returns an error' do
+        expect(subject["error"]).not_to be_empty
+        expect(subject["error"]).to match(/not authorized/i)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,238 @@
+# 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 'returns 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)
+          review.feedback_reviews << create(:feedback_review, review: review)
+          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["reviews"][0]["feedback_reviews"].count).to eq(1)
+          expect(subject["reviews"][0]["verified_purchaser"]).to eq(false)
+          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 'returns 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 'returns 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 'returns 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 'returns 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
+    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
+
+    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
+
+    context 'when user has already reviewed this product' do
+      before do
+        review.update(user_id: user.id)
+      end
+
+      it 'returns 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 'returns 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
+    subject do
+      put :update, params: params
+      JSON.parse(response.body)
+    end
+
+    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
+
+    context 'when a user updates their own review' do
+      it 'successfullies 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 'returns an error' do
+        expect(subject["error"]).not_to be_empty
+        expect(subject["error"]).to match(/not authorized/i)
+      end
+    end
+  end
+
+  describe '#destroy' do
+    subject do
+      delete :destroy, params: params
+      JSON.parse(response.body)
+    end
+
+    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' } }
+
+    context "when a user destroys their own review" do
+      it 'returns 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 'returns an error' do
+        expect(subject["error"]).not_to be_empty
+        expect(subject["error"]).to match(/not authorized/i)
+      end
+    end
+  end
+end

data/spec/controllers/spree/feedback_reviews_controller_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::FeedbackReviewsController do
+  let(:user) { create(:user) }
+  let(:product) { create(:product) }
+  let(:review) { create(:review, user: user) }
+  let(:valid_attributes) do
+    { review_id: review.id,
+      user_id: user.id,
+      feedback_review: {
+        rating: '4 stars',
+        comment: 'some comment'
+      } }
+  end
+
+  before do
+    allow(controller).to receive(:spree_current_user).and_return(user)
+    allow(controller).to receive(:spree_user_signed_in?).and_return(true)
+    request.env['HTTP_REFERER'] = '/'
+  end
+
+  describe '#create' do
+    it 'creates a new feedback review' do
+      rating = 4
+      comment = ['Thanks for your review!', 'Cheers'].join("\n")
+      expect {
+        post :create, params: { review_id: review.id,
+                                feedback_review: {
+                                  comment: comment,
+                                  rating: rating
+                                },
+                                format: :js }
+        expect(response.status).to eq(200)
+        expect(response).to render_template(:create)
+      }.to change(Spree::Review, :count).by(1)
+      feedback_review = Spree::FeedbackReview.last
+      expect(feedback_review.comment).to eq(comment)
+      expect(feedback_review.review).to eq(review)
+      expect(feedback_review.rating).to eq(rating)
+      expect(feedback_review.user).to eq(user)
+    end
+
+    it 'redirects back to the calling page' do
+      post :create, params: valid_attributes
+      expect(response).to redirect_to '/'
+    end
+
+    it 'sets locale on feedback-review if required by config' do
+      stub_spree_preferences(Spree::Reviews::Config, track_locale: true)
+      post :create, params: valid_attributes
+      expect(assigns[:review].locale).to eq I18n.locale.to_s
+    end
+
+    it 'fails when user is not authorized' do
+      allow(controller).to receive(:authorize!).and_raise(RuntimeError)
+
+      expect {
+        post :create, params: valid_attributes
+      }.to raise_error
+    end
+
+    it 'removes all non-numbers from ratings parameter' do
+      post :create, params: valid_attributes
+      expect(controller.params[:feedback_review][:rating]).to eq '4'
+    end
+
+    it 'do not create feedback-review if review doesnt exist' do
+      expect {
+        post :create, params: valid_attributes.merge!(review_id: nil)
+      }.to raise_error ActionController::UrlGenerationError
+    end
+  end
+end