spree_api 3.0.10 → 3.1.0.rc1

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

@@ -60,12 +60,22 @@ describe Spree::Api::BaseController, :type => :controller do
     end
   end
 
-  it 'handles exceptions' do
+  it 'handles parameter missing exceptions' do
     expect(subject).to receive(:authenticate_user).and_return(true)
     expect(subject).to receive(:load_user_roles).and_return(true)
-    expect(subject).to receive(:index).and_raise(Exception.new("no joy"))
-    get :index, :token => "fake_key"
-    expect(json_response).to eq({ "exception" => "no joy" })
+    expect(subject).to receive(:index).and_raise(ActionController::ParameterMissing.new('foo'))
+    get :index, token: 'exception-message'
+    expect(json_response).to eql('exception' => 'param is missing or the value is empty: foo')
+  end
+
+  it 'handles record invalid exceptions' do
+    expect(subject).to receive(:authenticate_user).and_return(true)
+    expect(subject).to receive(:load_user_roles).and_return(true)
+    resource = Spree::Product.new
+    resource.valid? # get some errors
+    expect(subject).to receive(:index).and_raise(ActiveRecord::RecordInvalid.new(resource))
+    get :index, token: 'exception-message'
+    expect(json_response).to eql('exception' => "Validation failed: Name can't be blank, Shipping Category can't be blank, Price can't be blank")
   end
 
   it "maps semantic keys to nested_attributes keys" do
@@ -83,42 +93,4 @@ describe Spree::Api::BaseController, :type => :controller do
   it "lets a subclass override the product associations that are eager-loaded" do
     expect(controller.respond_to?(:product_includes, true)).to be
   end
-
-  describe '#error_during_processing' do
-    controller(FakesController) do
-      # GET /foo
-      # Simulates a failed API call.
-      def foo
-        raise StandardError
-      end
-    end
-
-    # What would be placed in config/initializers/spree.rb
-    Spree::Api::BaseController.error_notifier = Proc.new do |e, controller|
-      MockHoneybadger.notify_or_ignore(e, rack_env: controller.request.env)
-    end
-
-    ##
-    # Fake HB alert class
-    class MockHoneybadger
-      # https://github.com/honeybadger-io/honeybadger-ruby/blob/master/lib/honeybadger.rb#L136
-      def self.notify_or_ignore(exception, opts = {})
-      end
-    end
-
-    before do
-      user = double(email: "spree@example.com")
-      allow(user).to receive_message_chain :spree_roles, pluck: []
-      allow(Spree.user_class).to receive_messages find_by: user
-      @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
-        r.draw { get 'foo' => 'fakes#foo' }
-      end
-    end
-
-    it 'should notify notify_error_during_processing' do
-      expect(MockHoneybadger).to receive(:notify_or_ignore).once.with(kind_of(Exception), rack_env: kind_of(Hash))
-      api_get :foo, token: 123
-      expect(response.status).to eq(422)
-    end
-  end
 end

data/spec/controllers/spree/api/{addresses_controller_spec.rb → v1/addresses_controller_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::AddressesController, :type => :controller do
+  describe Api::V1::AddressesController, :type => :controller do
     render_views
 
     before do

data/spec/controllers/spree/api/{checkouts_controller_spec.rb → v1/checkouts_controller_spec.rb}

@@ -1,9 +1,39 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::CheckoutsController, type: :controller do
+  describe Api::V1::CheckoutsController, type: :controller do
     render_views
 
+    shared_examples_for 'action which loads order using load_order_with_lock' do
+      before do
+        allow(controller).to receive(:load_order).with(true).and_return(true)
+      end
+
+      it 'should invoke load_order_with_lock' do
+        expect(controller).to receive(:load_order_with_lock).exactly(1).times
+      end
+
+      it 'should invoke load_order' do
+        expect(controller).to receive(:load_order).with(true).exactly(1).times.and_return(true)
+      end
+
+      context 'ensure no double_render_error' do
+        before do
+          def controller.load_order(*)
+            respond_with(@order, default_template: 'spree/api/v1/orders/show', status: 200)
+          end
+        end
+
+        it 'should not generate double_render_error' do
+          expect(response).to be_success
+        end
+      end
+
+      after do
+        send_request
+      end
+    end
+
     before(:each) do
       stub_authentication!
       Spree::Config[:track_inventory_levels] = false
@@ -211,7 +241,7 @@ module Spree
       end
 
       it "can transition from confirm to complete" do
-        order.update_columns(completed_at: Time.now, state: 'complete')
+        order.update_columns(state: 'confirm')
         allow_any_instance_of(Spree::Order).to receive_messages(payment_required?: false)
         api_put :update, id: order.to_param, order_token: order.guest_token
         expect(json_response['state']).to eq('complete')
@@ -219,7 +249,7 @@ module Spree
       end
 
       it "returns the order if the order is already complete" do
-        order.update_columns(completed_at: Time.now, state: 'complete')
+        order.update_columns(completed_at: Time.current, state: 'complete')
         api_put :update, id: order.to_param, order_token: order.guest_token
         expect(json_response['number']).to eq(order.number)
         expect(response.status).to eq(200)
@@ -260,6 +290,12 @@ module Spree
         expect_any_instance_of(PromotionHandler::Coupon).to receive(:apply).and_return({ coupon_applied?: true })
         api_put :update, :id => order.to_param, order_token: order.guest_token, order: { coupon_code: "foobar" }
       end
+
+      def send_request
+        api_put :update, id: order.to_param, order_token: order.guest_token
+      end
+
+      it_should_behave_like 'action which loads order using load_order_with_lock'
     end
 
     context "PUT 'next'" do
@@ -296,6 +332,12 @@ module Spree
         api_put :next, id: order.to_param, order_token: order.guest_token, order: {}
         expect(json_response["errors"]["base"]).to include(Spree.t(:no_payment_found))
       end
+
+      def send_request
+        api_put :next, id: order.to_param, order_token: order.guest_token
+      end
+
+      it_should_behave_like 'action which loads order using load_order_with_lock'
     end
 
     context "PUT 'advance'" do
@@ -310,6 +352,12 @@ module Spree
         api_put :advance, id: order.to_param, order_token: order.guest_token
         expect(json_response['id']).to eq(order.id)
       end
+
+      def send_request
+        api_put :advance, id: order.to_param, order_token: order.guest_token
+      end
+
+      it_should_behave_like 'action which loads order using load_order_with_lock'
     end
   end
 end

data/spec/controllers/spree/api/{classifications_controller_spec.rb → v1/classifications_controller_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ClassificationsController, type: :controller do
+  describe Api::V1::ClassificationsController, type: :controller do
     let(:taxon) do
       taxon = create(:taxon)
 
@@ -37,7 +37,7 @@ module Spree
       end
 
       it "should touch the taxon" do
-        taxon.update_attributes(updated_at: Time.now - 10.seconds)
+        taxon.update_attributes(updated_at: Time.current - 10.seconds)
         taxon_last_updated_at = taxon.updated_at
         api_put :update, taxon_id: taxon, product_id: last_product, position: 0
         taxon.reload

data/spec/controllers/spree/api/{countries_controller_spec.rb → v1/countries_controller_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::CountriesController, :type => :controller do
+  describe Api::V1::CountriesController, :type => :controller do
     render_views
 
     before do

data/spec/controllers/spree/api/{credit_cards_controller_spec.rb → v1/credit_cards_controller_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::CreditCardsController, :type => :controller do
+  describe Api::V1::CreditCardsController, :type => :controller do
     render_views
 
     let!(:admin_user) do

data/spec/controllers/spree/api/{images_controller_spec.rb → v1/images_controller_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::ImagesController, :type => :controller do
+  describe Api::V1::ImagesController, :type => :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -16,6 +16,12 @@ module Spree
     context "as an admin" do
       sign_in_as_admin!
 
+      it "can learn how to create a new image" do
+        api_get :new, product_id: product.id
+        expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
+        expect(json_response["required_attributes"]).to be_empty
+      end
+
       it "can upload a new image for a variant" do
         expect do
           api_post :create,
@@ -28,6 +34,15 @@ module Spree
         end.to change(Image, :count).by(1)
       end
 
+      it "can't upload a new image for a variant without attachment" do
+        api_post :create,
+                 image: { viewable_type: 'Spree::Variant',
+                          viewable_id: product.master.to_param
+                        },
+                 product_id: product.id
+        expect(response.status).to eq(422)
+      end
+
       context "working with an existing image" do
         let!(:product_image) { product.master.images.create!(:attachment => image('thinking-cat.jpg')) }
 
@@ -65,6 +80,13 @@ module Spree
           expect(product_image.reload.position).to eq(2)
         end
 
+        it "can't update a image without attachment" do
+          api_post :update,
+                   image: { attachment: nil },
+                   id: product_image.id, product_id: product.id
+          expect(response.status).to eq(422)
+        end
+
         it "can delete an image" do
           api_delete :destroy, :id => product_image.id, :product_id => product.id
           expect(response.status).to eq(204)

data/spec/controllers/spree/api/{inventory_units_controller_spec.rb → v1/inventory_units_controller_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::InventoryUnitsController, :type => :controller do
+  describe Api::V1::InventoryUnitsController, :type => :controller do
     render_views
 
     before do

data/spec/controllers/spree/api/{line_items_controller_spec.rb → v1/line_items_controller_spec.rb}

@@ -10,9 +10,9 @@ module Spree
   end
 
   # This should go in an initializer
-  Spree::Api::LineItemsController.line_item_options += [:some_option]
+  Spree::Api::V1::LineItemsController.line_item_options += [:some_option]
 
-  describe Api::LineItemsController, :type => :controller do
+  describe Api::V1::LineItemsController, :type => :controller do
     render_views
 
     let!(:order) { create(:order_with_line_items, line_items_count: 1) }

data/spec/controllers/spree/api/{option_types_controller_spec.rb → v1/option_types_controller_spec.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::OptionTypesController, :type => :controller do
+  describe Api::V1::OptionTypesController, :type => :controller do
     render_views
 
-    let(:attributes) { [:id, :name, :position, :presentation] }
+    let(:attributes) { [:id, :name, :presentation, :position] }
     let!(:option_value) { create(:option_value) }
     let!(:option_type) { option_value.option_type }
 
@@ -15,7 +15,7 @@ module Spree
     def check_option_values(option_values)
       expect(option_values.count).to eq(1)
       expect(option_values.first).to have_attributes([:id, :name, :presentation,
-                                                  :option_type_name, :option_type_id])
+                                                      :option_type_id, :option_type_name])
     end
 
     it "can list all option types" do
@@ -48,6 +48,12 @@ module Spree
       check_option_values(json_response["option_values"])
     end
 
+    it "can learn how to create a new option type" do
+      api_get :new
+      expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
+      expect(json_response["required_attributes"]).to_not be_empty
+    end
+
     it "cannot create a new option type" do
       api_post :create, :option_type => {
                         :name => "Option Type",

data/spec/controllers/spree/api/{option_values_controller_spec.rb → v1/option_values_controller_spec.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::OptionValuesController, :type => :controller do
+  describe Api::V1::OptionValuesController, :type => :controller do
     render_views
 
-    let(:attributes) { [:id, :name, :presentation, :option_type_name, :option_type_name] }
+    let(:attributes) { [:id, :name, :presentation, :option_type_name, :option_type_id, :option_type_presentation] }
     let!(:option_value) { create(:option_value) }
     let!(:option_type) { option_value.option_type }
 
@@ -86,6 +86,12 @@ module Spree
       context "as an admin" do
         sign_in_as_admin!
 
+        it "can learn how to create a new option value" do
+          api_get :new
+          expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
+          expect(json_response["required_attributes"]).to_not be_empty
+        end
+
         it "can create an option value" do
           api_post :create, :option_value => {
                             :name => "Option Value",

data/spec/controllers/spree/api/{orders_controller_spec.rb → v1/orders_controller_spec.rb}

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'spree/testing_support/bar_ability'
 
 module Spree
-  describe Api::OrdersController, :type => :controller do
+  describe Api::V1::OrdersController, :type => :controller do
     render_views
 
     let!(:order) { create(:order) }
@@ -12,7 +12,7 @@ module Spree
     let(:attributes) do
       [:number, :item_total, :display_total, :total, :state, :adjustment_total, :user_id,
        :created_at, :updated_at, :completed_at, :payment_total, :shipment_state, :payment_state,
-       :email, :special_instructions, :total_quantity, :display_item_total, :currency]
+       :email, :special_instructions, :total_quantity, :display_item_total, :currency, :considered_risky]
     end
 
     let(:address_params) { { :country_id => Country.first.id, :state_id => State.first.id } }
@@ -65,9 +65,9 @@ module Spree
       end
 
       it "returns orders in reverse chronological order by completed_at" do
-        order.update_columns completed_at: Time.now
+        order.update_columns completed_at: Time.current
 
-        order2 = Order.create user: order.user, completed_at: Time.now - 1.day
+        order2 = Order.create user: order.user, completed_at: Time.current - 1.day
         expect(order2.created_at).to be > order.created_at
         order3 = Order.create user: order.user, completed_at: nil
         expect(order3.created_at).to be > order2.created_at
@@ -222,7 +222,7 @@ module Spree
     end
 
     it "cannot cancel an order that doesn't belong to them" do
-      order.update_attribute(:completed_at, Time.now)
+      order.update_attribute(:completed_at, Time.current)
       order.update_attribute(:shipment_state, "ready")
       api_put :cancel, :id => order.to_param
       assert_unauthorized!
@@ -291,7 +291,9 @@ module Spree
     it "does not update line item needlessly" do
       expect(Order).to receive(:create!).and_return(order = Spree::Order.new)
       allow(order).to receive(:associate_user!)
-      allow(order).to receive_message_chain(:contents, :add).and_return(line_item = double('LineItem'))
+      line_item = double('LineItem')
+      allow(line_item).to receive_messages(save!: line_item)
+      allow(order).to receive_message_chain(:contents, :add).and_return(line_item)
       expect(line_item).not_to receive(:update_attributes)
       api_post :create, order: { line_items: [{ variant_id: variant.to_param, quantity: 5 }] }
     end
@@ -694,17 +696,36 @@ module Spree
 
       context "can cancel an order" do
         before do
-          order.completed_at = Time.now
+          order.completed_at = Time.current
           order.state = 'complete'
           order.shipment_state = 'ready'
           order.save!
         end
 
         specify do
-          api_put :cancel, :id => order.to_param
+          api_put :cancel, id: order.to_param
           expect(json_response["state"]).to eq("canceled")
+          expect(json_response["canceler_id"]).to eq(current_api_user.id)
+        end
+      end
+
+      context "can approve an order" do
+        before do
+          order.completed_at = Time.current
+          order.state = 'complete'
+          order.shipment_state = 'ready'
+          order.considered_risky = true
+          order.save!
+        end
+
+        specify do
+          api_put :approve, id: order.to_param
+          order.reload
+          expect(order.approver_id).to eq(current_api_user.id)
+          expect(order.considered_risky).to eq(false)
         end
       end
+
     end
   end
 end

data/spec/controllers/spree/api/{payments_controller_spec.rb → v1/payments_controller_spec.rb}

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::PaymentsController, :type => :controller do
+  describe Api::V1::PaymentsController, :type => :controller do
     render_views
     let!(:order) { create(:order) }
     let!(:payment) { create(:payment, :order => order) }
     let!(:attributes) { [:id, :source_type, :source_id, :amount, :display_amount,
                          :payment_method_id, :state, :avs_response,
-                         :created_at, :updated_at] }
+                         :created_at, :updated_at, :number] }
 
     let(:resource_scoping) { { :order_id => order.to_param } }