spree_api 2.3.4 → 2.3.5

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree::Api
-  describe OrdersController do
+  describe OrdersController, :type => :controller do
     render_views
 
     before do
@@ -19,13 +19,13 @@ module Spree::Api
       end
 
       it "can apply a coupon code to the order" do
-        order.total.should == 110.00
+        expect(order.total).to eq(110.00)
         api_put :apply_coupon_code, :id => order.to_param, :coupon_code => "10off", :order_token => order.guest_token
-        response.status.should == 200
-        order.reload.total.should == 109.00
-        json_response["success"].should == "The coupon code was successfully applied to your order."
-        json_response["error"].should be_blank
-        json_response["successful"].should be true
+        expect(response.status).to eq(200)
+        expect(order.reload.total).to eq(109.00)
+        expect(json_response["success"]).to eq("The coupon code was successfully applied to your order.")
+        expect(json_response["error"]).to be_blank
+        expect(json_response["successful"]).to be true
       end
 
       context "with an expired promotion" do
@@ -37,10 +37,10 @@ module Spree::Api
 
         it "fails to apply" do
           api_put :apply_coupon_code, :id => order.to_param, :coupon_code => "10off", :order_token => order.guest_token
-          response.status.should == 422
-          json_response["success"].should be_blank
-          json_response["error"].should == "The coupon code is expired"
-          json_response["successful"].should be false
+          expect(response.status).to eq(422)
+          expect(json_response["success"]).to be_blank
+          expect(json_response["error"]).to eq("The coupon code is expired")
+          expect(json_response["successful"]).to be false
         end
       end
     end

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 module Spree
-  describe Spree::Api::PropertiesController do
+  describe Spree::Api::PropertiesController, :type => :controller do
     render_views
 
     let!(:property_1) { Property.create!(:name => "foo", :presentation => "Foo") }
@@ -14,50 +14,50 @@ module Spree
 
     it "can see a list of all properties" do
       api_get :index
-      json_response["properties"].count.should eq(2)
-      json_response["properties"].first.should have_attributes(attributes)
+      expect(json_response["properties"].count).to eq(2)
+      expect(json_response["properties"].first).to have_attributes(attributes)
     end
 
     it "can control the page size through a parameter" do
       api_get :index, :per_page => 1
-      json_response['properties'].count.should == 1
-      json_response['current_page'].should == 1
-      json_response['pages'].should == 2
+      expect(json_response['properties'].count).to eq(1)
+      expect(json_response['current_page']).to eq(1)
+      expect(json_response['pages']).to eq(2)
     end
 
     it 'can query the results through a parameter' do
       api_get :index, :q => { :name_cont => 'ba' }
-      json_response['count'].should == 1
-      json_response['properties'].first['presentation'].should eq property_2.presentation
+      expect(json_response['count']).to eq(1)
+      expect(json_response['properties'].first['presentation']).to eq property_2.presentation
     end
 
     it "retrieves a list of properties by id" do
       api_get :index, :ids => [property_1.id]
-      json_response["properties"].first.should have_attributes(attributes)
-      json_response["count"].should == 1
+      expect(json_response["properties"].first).to have_attributes(attributes)
+      expect(json_response["count"]).to eq(1)
     end
 
     it "retrieves a list of properties by ids string" do
       api_get :index, :ids => [property_1.id, property_2.id].join(",")
-      json_response["properties"].first.should have_attributes(attributes)
-      json_response["properties"][1].should have_attributes(attributes)
-      json_response["count"].should == 2
+      expect(json_response["properties"].first).to have_attributes(attributes)
+      expect(json_response["properties"][1]).to have_attributes(attributes)
+      expect(json_response["count"]).to eq(2)
     end
 
     it "can see a single property" do
       api_get :show, :id => property_1.id
-      json_response.should have_attributes(attributes)
+      expect(json_response).to have_attributes(attributes)
     end
 
     it "can see a property by name" do
       api_get :show, :id => property_1.name
-      json_response.should have_attributes(attributes)
+      expect(json_response).to have_attributes(attributes)
     end
 
     it "can learn how to create a new property" do
       api_get :new
-      json_response["attributes"].should == attributes.map(&:to_s)
-      json_response["required_attributes"].should be_empty
+      expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
+      expect(json_response["required_attributes"]).to be_empty
     end
 
     it "cannot create a new property if not an admin" do
@@ -73,29 +73,29 @@ module Spree
     it "cannot delete a property" do
       api_delete :destroy, :id => property_1.id
       assert_unauthorized!
-      lambda { property_1.reload }.should_not raise_error
+      expect { property_1.reload }.not_to raise_error
     end
 
     context "as an admin" do
       sign_in_as_admin!
 
       it "can create a new property" do
-        Spree::Property.count.should == 2
+        expect(Spree::Property.count).to eq(2)
         api_post :create, :property => { :name => "My Property 3", :presentation => "my value 3" }
-        json_response.should have_attributes(attributes)
-        response.status.should == 201
-        Spree::Property.count.should == 3
+        expect(json_response).to have_attributes(attributes)
+        expect(response.status).to eq(201)
+        expect(Spree::Property.count).to eq(3)
       end
 
       it "can update a property" do
         api_put :update, :id => property_1.name, :property => { :presentation => "my value 456" }
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it "can delete a property" do
         api_delete :destroy, :id => property_1.name
-        response.status.should == 204
-        lambda { property_1.reload }.should raise_error(ActiveRecord::RecordNotFound)
+        expect(response.status).to eq(204)
+        expect { property_1.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ReturnAuthorizationsController do
+  describe Api::ReturnAuthorizationsController, :type => :controller do
     render_views
 
     let!(:order) { create(:shipped_order) }
@@ -16,7 +16,7 @@ module Spree
 
     context "as the order owner" do
       before do
-        Order.any_instance.stub :user => current_api_user
+        allow_any_instance_of(Order).to receive_messages :user => current_api_user
       end
 
       it "cannot see any return authorizations" do
@@ -57,28 +57,28 @@ module Spree
         FactoryGirl.create(:return_authorization, :order => order)
         return_authorization = order.return_authorizations.first
         api_get :show, :order_id => order.number, :id => return_authorization.id
-        response.status.should == 200
-        json_response.should have_attributes(attributes)
-        json_response["state"].should_not be_blank
+        expect(response.status).to eq(200)
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response["state"]).not_to be_blank
       end
 
       it "can get a list of return authorizations" do
         FactoryGirl.create(:return_authorization, :order => order)
         FactoryGirl.create(:return_authorization, :order => order)
         api_get :index, { :order_id => order.number }
-        response.status.should == 200
+        expect(response.status).to eq(200)
         return_authorizations = json_response["return_authorizations"]
-        return_authorizations.first.should have_attributes(attributes)
-        return_authorizations.first.should_not == return_authorizations.last
+        expect(return_authorizations.first).to have_attributes(attributes)
+        expect(return_authorizations.first).not_to eq(return_authorizations.last)
       end
 
       it 'can control the page size through a parameter' do
         FactoryGirl.create(:return_authorization, :order => order)
         FactoryGirl.create(:return_authorization, :order => order)
         api_get :index, :order_id => order.number, :per_page => 1
-        json_response['count'].should == 1
-        json_response['current_page'].should == 1
-        json_response['pages'].should == 2
+        expect(json_response['count']).to eq(1)
+        expect(json_response['current_page']).to eq(1)
+        expect(json_response['pages']).to eq(2)
       end
 
       it 'can query the results through a paramter' do
@@ -86,85 +86,85 @@ module Spree
         expected_result = create(:return_authorization, :reason => 'damaged')
         order.return_authorizations << expected_result
         api_get :index, :q => { :reason_cont => 'damage' }
-        json_response['count'].should == 1
-        json_response['return_authorizations'].first['reason'].should eq expected_result.reason
+        expect(json_response['count']).to eq(1)
+        expect(json_response['return_authorizations'].first['reason']).to eq expected_result.reason
       end
 
       it "can learn how to create a new return authorization" do
         api_get :new
-        json_response["attributes"].should == ["id", "number", "state", "amount", "order_id", "reason", "created_at", "updated_at"]
+        expect(json_response["attributes"]).to eq(["id", "number", "state", "amount", "order_id", "reason", "created_at", "updated_at"])
         required_attributes = json_response["required_attributes"]
-        required_attributes.should include("order")
+        expect(required_attributes).to include("order")
       end
 
       it "can update a return authorization on the order" do
         FactoryGirl.create(:return_authorization, :order => order)
         return_authorization = order.return_authorizations.first
         api_put :update, :id => return_authorization.id, :return_authorization => { :amount => 19.99 }
-        response.status.should == 200
-        json_response.should have_attributes(attributes)
+        expect(response.status).to eq(200)
+        expect(json_response).to have_attributes(attributes)
       end
 
       it "can add an inventory unit to a return authorization on the order" do
         FactoryGirl.create(:return_authorization, :order => order)
         return_authorization = order.return_authorizations.first
         inventory_unit = return_authorization.returnable_inventory.first
-        inventory_unit.should be
-        return_authorization.inventory_units.should be_empty
+        expect(inventory_unit).to be
+        expect(return_authorization.inventory_units).to be_empty
         api_put :add, :id => return_authorization.id, variant_id: inventory_unit.variant.id, quantity: 1
-        response.status.should == 200
-        json_response.should have_attributes(attributes)
-        return_authorization.reload.inventory_units.should_not be_empty
+        expect(response.status).to eq(200)
+        expect(json_response).to have_attributes(attributes)
+        expect(return_authorization.reload.inventory_units).not_to be_empty
       end
 
       it "can mark a return authorization as received on the order with an inventory unit" do
         FactoryGirl.create(:new_return_authorization, :order => order, :stock_location_id => order.shipments.first.stock_location.id)
         return_authorization = order.return_authorizations.first
-        return_authorization.state.should == "authorized"
+        expect(return_authorization.state).to eq("authorized")
 
         # prep (use a rspec context or a factory instead?)
         inventory_unit = return_authorization.returnable_inventory.first
-        inventory_unit.should be
-        return_authorization.inventory_units.should be_empty
+        expect(inventory_unit).to be
+        expect(return_authorization.inventory_units).to be_empty
         api_put :add, :id => return_authorization.id, variant_id: inventory_unit.variant.id, quantity: 1
         # end prep
 
         api_delete :receive, :id => return_authorization.id
-        response.status.should == 200
-        return_authorization.reload.state.should == "received"
+        expect(response.status).to eq(200)
+        expect(return_authorization.reload.state).to eq("received")
       end
 
       it "cannot mark a return authorization as received on the order with no inventory units" do
         FactoryGirl.create(:new_return_authorization, :order => order)
         return_authorization = order.return_authorizations.first
-        return_authorization.state.should == "authorized"
+        expect(return_authorization.state).to eq("authorized")
         api_delete :receive, :id => return_authorization.id
-        response.status.should == 422
-        return_authorization.reload.state.should == "authorized"
+        expect(response.status).to eq(422)
+        expect(return_authorization.reload.state).to eq("authorized")
       end
 
       it "can cancel a return authorization on the order" do
         FactoryGirl.create(:new_return_authorization, :order => order)
         return_authorization = order.return_authorizations.first
-        return_authorization.state.should == "authorized"
+        expect(return_authorization.state).to eq("authorized")
         api_delete :cancel, :id => return_authorization.id
-        response.status.should == 200
-        return_authorization.reload.state.should == "canceled"
+        expect(response.status).to eq(200)
+        expect(return_authorization.reload.state).to eq("canceled")
       end
 
       it "can delete a return authorization on the order" do
         FactoryGirl.create(:return_authorization, :order => order)
         return_authorization = order.return_authorizations.first
         api_delete :destroy, :id => return_authorization.id
-        response.status.should == 204
-        lambda { return_authorization.reload }.should raise_error(ActiveRecord::RecordNotFound)
+        expect(response.status).to eq(204)
+        expect { return_authorization.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end
 
       it "can add a new return authorization to an existing order" do
         api_post :create, :order_id => order.number, :return_authorization => { :amount => 14.22, :reason => "Defective" }
-        response.status.should == 201
-        json_response.should have_attributes(attributes)
-        json_response["state"].should_not be_blank
+        expect(response.status).to eq(201)
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response["state"]).not_to be_blank
       end
     end
 
@@ -179,7 +179,7 @@ module Spree
         return_authorization = order.return_authorizations.first
         api_put :update, :id => return_authorization.id, :return_authorization => { :amount => 19.99 }
         assert_unauthorized!
-        return_authorization.reload.amount.should_not == 19.99
+        expect(return_authorization.reload.amount).not_to eq(19.99)
       end
 
       it "cannot delete a return authorization on the order" do
@@ -187,7 +187,7 @@ module Spree
         return_authorization = order.return_authorizations.first
         api_delete :destroy, :id => return_authorization.id
         assert_unauthorized!
-        lambda { return_authorization.reload }.should_not raise_error
+        expect { return_authorization.reload }.not_to raise_error
       end
     end
   end

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Api::ShipmentsController do
+describe Spree::Api::ShipmentsController, :type => :controller do
   render_views
   let!(:shipment) { create(:shipment) }
   let!(:attributes) { [:id, :tracking, :number, :cost, :shipped_at, :stock_location_name, :order_id, :shipping_rates, :shipping_methods] }
@@ -27,18 +27,41 @@ describe Spree::Api::ShipmentsController do
     let!(:order) { shipment.order }
     let!(:stock_location) { create(:stock_location_with_items) }
     let!(:variant) { create(:variant) }
+
     sign_in_as_admin!
 
-    it 'can create a new shipment' do
-      params = {
-        variant_id: stock_location.stock_items.first.variant.to_param,
-        shipment: { order_id: order.number },
-        stock_location_id: stock_location.to_param,
-      }
+    # Start writing this spec a bit differently than before....
+    describe 'POST #create' do
+      let(:params) do
+        {
+          variant_id: stock_location.stock_items.first.variant.to_param,
+          shipment: { order_id: order.number },
+          stock_location_id: stock_location.to_param
+        }
+      end 
+      
+      subject do 
+        api_post :create, params
+      end
+
+      [:variant_id, :stock_location_id].each do |field|
+        context "when #{field} is missing" do
+          before do
+            params.delete(field)
+          end
+
+          it 'should return proper error' do
+            subject
+            expect(response.status).to eq(422)
+            expect(json_response['exception']).to eq("param is missing or the value is empty: #{field.to_s}")
+          end
+        end
+      end
 
-      api_post :create, params
-      response.status.should == 200
-      json_response.should have_attributes(attributes)
+      it 'should create a new shipment' do
+        expect(subject).to be_ok
+        expect(json_response).to have_attributes(attributes)
+      end
     end
 
     it 'can update a shipment' do
@@ -49,23 +72,23 @@ describe Spree::Api::ShipmentsController do
       }
 
       api_put :update, params
-      response.status.should == 200
-      json_response['stock_location_name'].should == stock_location.name
+      expect(response.status).to eq(200)
+      expect(json_response['stock_location_name']).to eq(stock_location.name)
     end
 
     it "can make a shipment ready" do
-      Spree::Order.any_instance.stub(:paid? => true, :complete? => true)
+      allow_any_instance_of(Spree::Order).to receive_messages(:paid? => true, :complete? => true)
       api_put :ready
-      json_response.should have_attributes(attributes)
-      json_response["state"].should == "ready"
-      shipment.reload.state.should == "ready"
+      expect(json_response).to have_attributes(attributes)
+      expect(json_response["state"]).to eq("ready")
+      expect(shipment.reload.state).to eq("ready")
     end
 
     it "cannot make a shipment ready if the order is unpaid" do
-      Spree::Order.any_instance.stub(:paid? => false)
+      allow_any_instance_of(Spree::Order).to receive_messages(:paid? => false)
       api_put :ready
-      json_response["error"].should == "Cannot ready shipment."
-      response.status.should == 422
+      expect(json_response["error"]).to eq("Cannot ready shipment.")
+      expect(response.status).to eq(422)
     end
 
     context 'for completed shipments' do
@@ -74,16 +97,16 @@ describe Spree::Api::ShipmentsController do
 
       it 'adds a variant to a shipment' do
         api_put :add, { variant_id: variant.to_param, quantity: 2 }
-        response.status.should == 200
-        json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"].should == 2
+        expect(response.status).to eq(200)
+        expect(json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"]).to eq(2)
       end
 
       it 'removes a variant from a shipment' do
         order.contents.add(variant, 2)
 
         api_put :remove, { variant_id: variant.to_param, quantity: 1 }
-        response.status.should == 200
-        json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"].should == 1
+        expect(response.status).to eq(200)
+        expect(json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"]).to eq(1)
       end
 
       it 'removes a destroyed variant from a shipment' do
@@ -91,27 +114,27 @@ describe Spree::Api::ShipmentsController do
         variant.destroy
 
         api_put :remove, { variant_id: variant.to_param, quantity: 1 }
-        response.status.should == 200
-        json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"].should == 1
+        expect(response.status).to eq(200)
+        expect(json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"]).to eq(1)
       end
     end
 
     context "can transition a shipment from ready to ship" do
       before do
-        Spree::Order.any_instance.stub(:paid? => true, :complete? => true)
+        allow_any_instance_of(Spree::Order).to receive_messages(:paid? => true, :complete? => true)
         # For the shipment notification email
         Spree::Config[:mails_from] = "spree@example.com"
 
         shipment.update!(shipment.order)
-        shipment.state.should == "ready"
-        Spree::ShippingRate.any_instance.stub(:cost => 5)
+        expect(shipment.state).to eq("ready")
+        allow_any_instance_of(Spree::ShippingRate).to receive_messages(:cost => 5)
       end
 
       it "can transition a shipment from ready to ship" do
         shipment.reload
         api_put :ship, id: shipment.to_param, shipment: { tracking: "123123", order_id: shipment.order.to_param }
-        json_response.should have_attributes(attributes)
-        json_response["state"].should == "shipped"
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response["state"]).to eq("shipped")
       end
 
     end