spree_api 2.3.13 → 2.4.0.rc1

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

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ReturnAuthorizationsController, :type => :controller do
+  describe Api::ReturnAuthorizationsController do
     render_views
 
     let!(:order) { create(:shipped_order) }
 
     let(:product) { create(:product) }
-    let(:attributes) { [:id, :reason, :amount, :state] }
+    let(:attributes) { [:id, :memo, :state] }
     let(:resource_scoping) { { :order_id => order.to_param } }
 
     before do
@@ -16,7 +16,7 @@ module Spree
 
     context "as the order owner" do
       before do
-        allow_any_instance_of(Order).to receive_messages :user => current_api_user
+        Order.any_instance.stub :user => current_api_user
       end
 
       it "cannot see any return authorizations" do
@@ -57,129 +57,105 @@ 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
-        expect(response.status).to eq(200)
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["state"]).not_to be_blank
+        response.status.should == 200
+        json_response.should have_attributes(attributes)
+        json_response["state"].should_not 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 }
-        expect(response.status).to eq(200)
+        response.status.should == 200
         return_authorizations = json_response["return_authorizations"]
-        expect(return_authorizations.first).to have_attributes(attributes)
-        expect(return_authorizations.first).not_to eq(return_authorizations.last)
+        return_authorizations.first.should have_attributes(attributes)
+        return_authorizations.first.should_not == 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
-        expect(json_response['count']).to eq(1)
-        expect(json_response['current_page']).to eq(1)
-        expect(json_response['pages']).to eq(2)
+        json_response['count'].should == 1
+        json_response['current_page'].should == 1
+        json_response['pages'].should == 2
       end
 
       it 'can query the results through a paramter' do
         FactoryGirl.create(:return_authorization, :order => order)
-        expected_result = create(:return_authorization, :reason => 'damaged')
+        expected_result = create(:return_authorization, :memo => 'damaged')
         order.return_authorizations << expected_result
-        api_get :index, :q => { :reason_cont => 'damage' }
-        expect(json_response['count']).to eq(1)
-        expect(json_response['return_authorizations'].first['reason']).to eq expected_result.reason
+        api_get :index, :q => { :memo_cont => 'damaged' }
+        json_response['count'].should == 1
+        json_response['return_authorizations'].first['memo'].should eq expected_result.memo
       end
 
       it "can learn how to create a new return authorization" do
         api_get :new
-        expect(json_response["attributes"]).to eq(["id", "number", "state", "amount", "order_id", "reason", "created_at", "updated_at"])
+        json_response["attributes"].should == ["id", "number", "state", "order_id", "memo", "created_at", "updated_at"]
         required_attributes = json_response["required_attributes"]
-        expect(required_attributes).to include("order")
+        required_attributes.should 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 }
-        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
-        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
-        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
-        expect(return_authorization.state).to eq("authorized")
-
-        # prep (use a rspec context or a factory instead?)
-        inventory_unit = return_authorization.returnable_inventory.first
-        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
-        expect(response.status).to eq(200)
-        expect(return_authorization.reload.state).to eq("received")
+        api_put :update, :id => return_authorization.id, :return_authorization => { :memo => "ABC" }
+        response.status.should == 200
+        json_response.should have_attributes(attributes)
       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
-        expect(return_authorization.state).to eq("authorized")
+        return_authorization.state.should == "authorized"
         api_delete :receive, :id => return_authorization.id
-        expect(response.status).to eq(422)
-        expect(return_authorization.reload.state).to eq("authorized")
+        response.status.should == 422
+        return_authorization.reload.state.should == "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
-        expect(return_authorization.state).to eq("authorized")
+        return_authorization.state.should == "authorized"
         api_delete :cancel, :id => return_authorization.id
-        expect(response.status).to eq(200)
-        expect(return_authorization.reload.state).to eq("canceled")
+        response.status.should == 200
+        return_authorization.reload.state.should == "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
-        expect(response.status).to eq(204)
-        expect { return_authorization.reload }.to raise_error(ActiveRecord::RecordNotFound)
+        response.status.should == 204
+        lambda { return_authorization.reload }.should 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" }
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["state"]).not_to be_blank
+        stock_location = FactoryGirl.create(:stock_location)
+        reason = FactoryGirl.create(:return_authorization_reason)
+        rma_params = { :stock_location_id => stock_location.id,
+                       :return_authorization_reason_id => reason.id,
+                       :memo => "Defective" }
+        api_post :create, :order_id => order.number, :return_authorization => rma_params
+        response.status.should == 201
+        json_response.should have_attributes(attributes)
+        json_response["state"].should_not be_blank
       end
     end
 
     context "as just another user" do
       it "cannot add a return authorization to the order" do
-        api_post :create, :return_autorization => { :order_id => order.number, :amount => 14.22, :reason => "Defective" }
+        api_post :create, :return_autorization => { :order_id => order.number, :memo => "Defective" }
         assert_unauthorized!
       end
 
       it "cannot 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 }
+        api_put :update, :id => return_authorization.id, :return_authorization => { :memo => "ABC" }
         assert_unauthorized!
-        expect(return_authorization.reload.amount).not_to eq(19.99)
+        return_authorization.reload.memo.should_not == "ABC"
       end
 
       it "cannot delete a return authorization on the order" do
@@ -187,7 +163,7 @@ module Spree
         return_authorization = order.return_authorizations.first
         api_delete :destroy, :id => return_authorization.id
         assert_unauthorized!
-        expect { return_authorization.reload }.not_to raise_error
+        lambda { return_authorization.reload }.should_not 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, :type => :controller do
+describe Spree::Api::ShipmentsController do
   render_views
   let!(:shipment) { create(:shipment) }
   let!(:attributes) { [:id, :tracking, :number, :cost, :shipped_at, :stock_location_name, :order_id, :shipping_rates, :shipping_methods] }
@@ -72,23 +72,23 @@ describe Spree::Api::ShipmentsController, :type => :controller do
       }
 
       api_put :update, params
-      expect(response.status).to eq(200)
-      expect(json_response['stock_location_name']).to eq(stock_location.name)
+      response.status.should == 200
+      json_response['stock_location_name'].should == stock_location.name
     end
 
     it "can make a shipment ready" do
-      allow_any_instance_of(Spree::Order).to receive_messages(:paid? => true, :complete? => true)
+      Spree::Order.any_instance.stub(:paid? => true, :complete? => true)
       api_put :ready
-      expect(json_response).to have_attributes(attributes)
-      expect(json_response["state"]).to eq("ready")
-      expect(shipment.reload.state).to eq("ready")
+      json_response.should have_attributes(attributes)
+      json_response["state"].should == "ready"
+      shipment.reload.state.should == "ready"
     end
 
     it "cannot make a shipment ready if the order is unpaid" do
-      allow_any_instance_of(Spree::Order).to receive_messages(:paid? => false)
+      Spree::Order.any_instance.stub(:paid? => false)
       api_put :ready
-      expect(json_response["error"]).to eq("Cannot ready shipment.")
-      expect(response.status).to eq(422)
+      json_response["error"].should == "Cannot ready shipment."
+      response.status.should == 422
     end
 
     context 'for completed shipments' do
@@ -97,16 +97,16 @@ describe Spree::Api::ShipmentsController, :type => :controller do
 
       it 'adds a variant to a shipment' do
         api_put :add, { variant_id: variant.to_param, quantity: 2 }
-        expect(response.status).to eq(200)
-        expect(json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"]).to eq(2)
+        response.status.should == 200
+        json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"].should == 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 }
-        expect(response.status).to eq(200)
-        expect(json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"]).to eq(1)
+        response.status.should == 200
+        json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"].should == 1
       end
 
       it 'removes a destroyed variant from a shipment' do
@@ -114,29 +114,77 @@ describe Spree::Api::ShipmentsController, :type => :controller do
         variant.destroy
 
         api_put :remove, { variant_id: variant.to_param, quantity: 1 }
-        expect(response.status).to eq(200)
-        expect(json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"]).to eq(1)
+        response.status.should == 200
+        json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"].should == 1
       end
     end
 
     context "can transition a shipment from ready to ship" do
       before do
-        allow_any_instance_of(Spree::Order).to receive_messages(:paid? => true, :complete? => true)
+        Spree::Order.any_instance.stub(:paid? => true, :complete? => true)
         # For the shipment notification email
         Spree::Config[:mails_from] = "spree@example.com"
 
         shipment.update!(shipment.order)
-        expect(shipment.state).to eq("ready")
-        allow_any_instance_of(Spree::ShippingRate).to receive_messages(:cost => 5)
+        shipment.state.should == "ready"
+        Spree::ShippingRate.any_instance.stub(: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 }
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["state"]).to eq("shipped")
+        json_response.should have_attributes(attributes)
+        json_response["state"].should == "shipped"
       end
 
     end
+
+    describe '#mine' do
+      subject do
+        api_get :mine, format: 'json', params: params
+      end
+
+      let(:params) { {} }
+
+      before { subject }
+
+      context "the current api user is authenticated and has orders" do
+        let(:current_api_user) { shipped_order.user }
+        let(:shipped_order) { create(:shipped_order) }
+
+        it 'succeeds' do
+          expect(response.status).to eq 200
+        end
+
+        describe 'json output' do
+          render_views
+
+          let(:rendered_shipment_ids) { json_response['shipments'].map { |s| s['id'] } }
+
+          it 'contains the shipments' do
+            expect(rendered_shipment_ids).to match_array current_api_user.orders.flat_map(&:shipments).map(&:id)
+          end
+        end
+
+        context 'with filtering' do
+          let(:params) { {q: {order_completed_at_not_null: 1}} }
+
+          let!(:incomplete_order) { create(:order, user: current_api_user) }
+
+          it 'filters' do
+            expect(assigns(:shipments).map(&:id)).to match_array current_api_user.orders.complete.flat_map(&:shipments).map(&:id)
+          end
+        end
+      end
+
+      context "the current api user is not persisted" do
+        let(:current_api_user) { Spree.user_class.new }
+
+        it "returns a 401" do
+          response.status.should == 401
+        end
+      end
+    end
+
   end
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::StatesController, :type => :controller do
+  describe Api::StatesController do
     render_views
 
     let!(:state) { create(:state, :name => "Victoria") }
@@ -13,37 +13,37 @@ module Spree
 
     it "gets all states" do
       api_get :index
-      expect(json_response["states"].first).to have_attributes(attributes)
-      expect(json_response['states'].first['name']).to eq(state.name)
+      json_response["states"].first.should have_attributes(attributes)
+      json_response['states'].first['name'].should eq(state.name)
     end
 
     it "gets all the states for a particular country" do
       api_get :index, :country_id => state.country.id
-      expect(json_response["states"].first).to have_attributes(attributes)
-      expect(json_response['states'].first['name']).to eq(state.name)
+      json_response["states"].first.should have_attributes(attributes)
+      json_response['states'].first['name'].should eq(state.name)
     end
 
     context "pagination" do
       before do
-        expect(State).to receive(:accessible_by).and_return(@scope = double)
-        allow(@scope).to receive_message_chain(:ransack, :result, :includes, :order).and_return(@scope)
+        State.should_receive(:accessible_by).and_return(@scope = double)
+        @scope.stub_chain(:ransack, :result, :includes, :order).and_return(@scope)
       end
 
       it "does not paginate states results when asked not to do so" do
-        expect(@scope).not_to receive(:page)
-        expect(@scope).not_to receive(:per)
+        @scope.should_not_receive(:page)
+        @scope.should_not_receive(:per)
         api_get :index
       end
 
       it "paginates when page parameter is passed through" do
-        expect(@scope).to receive(:page).with(1).and_return(@scope)
-        expect(@scope).to receive(:per).with(nil)
+        @scope.should_receive(:page).with(1).and_return(@scope)
+        @scope.should_receive(:per).with(nil)
         api_get :index, :page => 1
       end
 
       it "paginates when per_page parameter is passed through" do
-        expect(@scope).to receive(:page).with(nil).and_return(@scope)
-        expect(@scope).to receive(:per).with(25)
+        @scope.should_receive(:page).with(nil).and_return(@scope)
+        @scope.should_receive(:per).with(25)
         api_get :index, :per_page => 25
       end
     end
@@ -58,25 +58,25 @@ module Spree
         state.save
 
         api_get :index, :country_id => country.id
-        expect(json_response["states"].first).to have_attributes(attributes)
-        expect(json_response["states"].count).to eq(1)
+        json_response["states"].first.should have_attributes(attributes)
+        json_response["states"].count.should == 1
         json_response["states_required"] = true
       end
 
       it "can view all states" do
         api_get :index
-        expect(json_response["states"].first).to have_attributes(attributes)
+        json_response["states"].first.should have_attributes(attributes)
       end
 
       it 'can query the results through a paramter' do
         api_get :index, :q => { :name_cont => 'Vic' }
-        expect(json_response['states'].first['name']).to eq("Victoria")
+        json_response['states'].first['name'].should eq("Victoria")
       end
     end
 
     it "can view a state" do
       api_get :show, :id => state.id
-      expect(json_response).to have_attributes(attributes)
+      json_response.should have_attributes(attributes)
     end
   end
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::StockItemsController, :type => :controller do
+  describe Api::StockItemsController do
     render_views
 
     let!(:stock_location) { create(:stock_location_with_items) }
@@ -16,12 +16,12 @@ module Spree
     context "as a normal user" do
       it "cannot list stock items for a stock location" do
         api_get :index, stock_location_id: stock_location.to_param
-        expect(response.status).to eq(404)
+        response.status.should == 404
       end
 
       it "cannot see a stock item" do
         api_get :show, stock_location_id: stock_location.to_param, id: stock_item.to_param
-        expect(response.status).to eq(404)
+        response.status.should == 404
       end
 
       it "cannot create a stock item" do
@@ -35,17 +35,17 @@ module Spree
         }
 
         api_post :create, params
-        expect(response.status).to eq(404)
+        response.status.should == 404
       end
 
       it "cannot update a stock item" do
         api_put :update, stock_location_id: stock_location.to_param, stock_item_id: stock_item.to_param
-        expect(response.status).to eq(404)
+        response.status.should == 404
       end
 
       it "cannot destroy a stock item" do
         api_delete :destroy, stock_location_id: stock_location.to_param, stock_item_id: stock_item.to_param
-        expect(response.status).to eq(404)
+        response.status.should == 404
       end
     end
 
@@ -54,33 +54,33 @@ module Spree
 
       it 'cannot list of stock items' do
         api_get :index, stock_location_id: stock_location.to_param
-        expect(json_response['stock_items'].first).to have_attributes(attributes)
-        expect(json_response['stock_items'].first['variant']['sku']).to include 'SKU'
+        json_response['stock_items'].first.should have_attributes(attributes)
+        json_response['stock_items'].first['variant']['sku'].should include 'SKU'
       end
 
       it 'requires a stock_location_id to be passed as a parameter' do
         api_get :index
-        expect(json_response['error']).to match(/stock_location_id parameter must be provided/)
-        expect(response.status).to eq(422)
+        json_response['error'].should =~ /stock_location_id parameter must be provided/
+        response.status.should == 422
       end
 
       it 'can control the page size through a parameter' do
         api_get :index, stock_location_id: stock_location.to_param, per_page: 1
-        expect(json_response['count']).to eq(1)
-        expect(json_response['current_page']).to eq(1)
+        json_response['count'].should == 1
+        json_response['current_page'].should == 1
       end
 
       it 'can query the results through a paramter' do
         stock_item.update_column(:count_on_hand, 30)
         api_get :index, stock_location_id: stock_location.to_param, q: { count_on_hand_eq: '30' }
-        expect(json_response['count']).to eq(1)
-        expect(json_response['stock_items'].first['count_on_hand']).to eq 30
+        json_response['count'].should == 1
+        json_response['stock_items'].first['count_on_hand'].should eq 30
       end
 
       it 'gets a stock item' do
         api_get :show, stock_location_id: stock_location.to_param, id: stock_item.to_param
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response['count_on_hand']).to eq stock_item.count_on_hand
+        json_response.should have_attributes(attributes)
+        json_response['count_on_hand'].should eq stock_item.count_on_hand
       end
 
       it 'can create a new stock item' do
@@ -97,12 +97,12 @@ module Spree
         }
 
         api_post :create, params
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
+        response.status.should == 201
+        json_response.should have_attributes(attributes)
       end
 
       it 'can update a stock item to add new inventory' do
-        expect(stock_item.count_on_hand).to eq(10)
+        stock_item.count_on_hand.should == 10
         params = {
           id: stock_item.to_param,
           stock_item: {
@@ -111,12 +111,12 @@ module Spree
         }
 
         api_put :update, params
-        expect(response.status).to eq(200)
-        expect(json_response['count_on_hand']).to eq 50
+        response.status.should == 200
+        json_response['count_on_hand'].should eq 50
       end
 
       it 'can set a stock item to modify the current inventory' do
-        expect(stock_item.count_on_hand).to eq(10)
+        stock_item.count_on_hand.should == 10
 
         params = {
           id: stock_item.to_param,
@@ -127,14 +127,14 @@ module Spree
         }
 
         api_put :update, params
-        expect(response.status).to eq(200)
-        expect(json_response['count_on_hand']).to eq 40
+        response.status.should == 200
+        json_response['count_on_hand'].should eq 40
       end
 
       it 'can delete a stock item' do
         api_delete :destroy, id: stock_item.to_param
-        expect(response.status).to eq(204)
-        expect { Spree::StockItem.find(stock_item.id) }.to raise_error(ActiveRecord::RecordNotFound)
+        response.status.should == 204
+        lambda { Spree::StockItem.find(stock_item.id) }.should raise_error(ActiveRecord::RecordNotFound)
       end
     end
   end