spree_api 2.0.13 → 2.1.0

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

@@ -5,12 +5,11 @@ module Spree
     render_views
     let!(:order) { create(:order) }
     let!(:payment) { create(:payment, :order => order) }
-    let!(:attributes) { [:id, :source_type, :source_id, :amount, :display_amount,
+    let!(:attributes) { [:id, :source_type, :source_id, :amount,
                          :payment_method_id, :response_code, :state, :avs_response,
                          :created_at, :updated_at] }
 
     let(:resource_scoping) { { :order_id => order.to_param } }
-
     before do
       stub_authentication!
     end
@@ -44,11 +43,6 @@ module Spree
           json_response.should have_attributes(attributes)
         end
 
-        it "cannot update a payment" do
-          api_put :update, :id => payment.to_param, :payment => { :amount => 2.01 }
-          assert_unauthorized!
-        end
-
         it "cannot authorize a payment" do
           api_put :authorize, :id => payment.to_param
           assert_unauthorized!
@@ -99,120 +93,84 @@ module Spree
       end
 
       context "for a given payment" do
-        context "updating" do
-          it "can update" do
-            payment.update_column(:state, 'pending')
-            api_put :update, :id => payment.to_param, :payment => { :amount => 2.01 }
-            response.status.should == 200
-            payment.reload.amount.should == 2.01
-          end
 
-          context "update fails" do
-            it "returns a 422 status when the amount is invalid" do
-              payment.update_column(:state, 'pending')
-              api_put :update, :id => payment.to_param, :payment => { :amount => 'invalid' }
-              response.status.should == 422
-              json_response["error"].should == "Invalid resource. Please fix errors and try again."
-            end
-
-            it "returns a 403 status when the payment is not pending" do
-              payment.update_column(:state, 'complete')
-              api_put :update, :id => payment.to_param, :payment => { :amount => 2.01 }
-              response.status.should == 403
-              json_response["error"].should == "This payment cannot be updated because it is complete."
-            end
-          end
+        it "can authorize" do
+          api_put :authorize, :id => payment.to_param
+          response.status.should == 200
+          payment.reload
+          payment.state.should == "pending"
         end
 
-        context "authorizing" do
-          it "can authorize" do
+        context "authorization fails" do
+          before do
+            fake_response = double(:success? => false, :to_s => "Could not authorize card")
+            Spree::Gateway::Bogus.any_instance.should_receive(:authorize).and_return(fake_response)
             api_put :authorize, :id => payment.to_param
-            response.status.should == 200
-            payment.reload.state.should == "pending"
+          end 
+
+          it "returns a 422 status" do
+            response.status.should == 422
+            json_response["error"].should == "There was a problem with the payment gateway: Could not authorize card"
           end
 
-          context "authorization fails" do
-            before do
-              fake_response = double(:success? => false, :to_s => "Could not authorize card")
-              Spree::Gateway::Bogus.any_instance.should_receive(:authorize).and_return(fake_response)
-              api_put :authorize, :id => payment.to_param
-            end
-
-            it "returns a 422 status" do
-              response.status.should == 422
-              json_response["error"].should == "There was a problem with the payment gateway: Could not authorize card"
-            end
-
-            it "does not raise a stack level error" do
-              pending "Investigate why a payment.reload after the request raises 'stack level too deep'"
-              payment.reload.state.should == "failed"
-            end
+          it "returns a 422 status" do
+            pending "Investigate why a payment.reload after the request raises 'stack level too deep'" 
+            payment.reload
+            payment.state.should == "failed"
           end
         end
 
-        context "capturing" do
-          it "can capture" do
-            api_put :capture, :id => payment.to_param
-            response.status.should == 200
-            payment.reload.state.should == "completed"
-          end
+        it "can capture" do
+          api_put :capture, :id => payment.to_param
+          response.status.should == 200
+          payment.reload
+          payment.state.should == "completed"
+        end
 
-          context "capturing fails" do
-            before do
-              fake_response = double(:success? => false, :to_s => "Insufficient funds")
-              Spree::Gateway::Bogus.any_instance.should_receive(:capture).and_return(fake_response)
-            end
-
-            it "returns a 422 status" do
-              api_put :capture, :id => payment.to_param
-              response.status.should == 422
-              json_response["error"].should == "There was a problem with the payment gateway: Insufficient funds"
-            end
-          end
+        it "returns a 422 status when purchasing fails" do
+          fake_response = double(:success? => false, :to_s => "Insufficient funds")
+          Spree::Gateway::Bogus.any_instance.should_receive(:capture).and_return(fake_response)
+          api_put :capture, :id => payment.to_param
+          response.status.should == 422
+          json_response["error"].should == "There was a problem with the payment gateway: Insufficient funds"
         end
 
-        context "purchasing" do
-          it "can purchase" do
-            api_put :purchase, :id => payment.to_param
-            response.status.should == 200
-            payment.reload.state.should == "completed"
-          end
+        it "can purchase" do
+          api_put :purchase, :id => payment.to_param
+          response.status.should == 200
+          payment.reload
+          payment.state.should == "completed"
+        end
 
-          context "purchasing fails" do
-            before do
-              fake_response = double(:success? => false, :to_s => "Insufficient funds")
-              Spree::Gateway::Bogus.any_instance.should_receive(:purchase).and_return(fake_response)
-            end
-
-            it "returns a 422 status" do
-              api_put :purchase, :id => payment.to_param
-              response.status.should == 422
-              json_response["error"].should == "There was a problem with the payment gateway: Insufficient funds"
-            end
+        context "purchasing fails" do
+          before do
+            fake_response = double(:success? => false, :to_s => "Insufficient funds")
+            Spree::Gateway::Bogus.any_instance.should_receive(:purchase).and_return(fake_response)
           end
-        end
 
-        context "voiding" do
-          it "can void" do
-            api_put :void, :id => payment.to_param
-            response.status.should == 200
-            payment.reload.state.should == "void"
+          it "returns a 422" do
+            api_put :purchase, :id => payment.to_param
+            response.status.should == 422
+            json_response["error"].should == "There was a problem with the payment gateway: Insufficient funds"
           end
+        end
 
-          context "voiding fails" do
-            before do
-              fake_response = double(:success? => false, :to_s => "NO REFUNDS")
-              Spree::Gateway::Bogus.any_instance.should_receive(:void).and_return(fake_response)
-            end
+        it "can void" do
+          api_put :void, :id => payment.to_param
+          response.status.should == 200
+          payment.reload
+          payment.state.should == "void"
+        end
 
-            it "returns a 422 status" do
-              api_put :void, :id => payment.to_param
-              response.status.should == 422
-              json_response["error"].should == "There was a problem with the payment gateway: NO REFUNDS"
+        it "returns a 422 status when voiding fails" do
+          fake_response = double(:success? => false, :to_s => "NO REFUNDS")
+          Spree::Gateway::Bogus.any_instance.should_receive(:void).and_return(fake_response)
+          api_put :void, :id => payment.to_param
+          response.status.should == 422
+          json_response["error"].should == "There was a problem with the payment gateway: NO REFUNDS"
 
-              payment.reload.state.should == "checkout"
-            end
-          end
+          payment.reload
+          payment.state.should == "checkout"
         end
 
         context "crediting" do
@@ -223,30 +181,31 @@ module Spree
           it "can credit" do
             api_put :credit, :id => payment.to_param
             response.status.should == 200
-            payment.reload.state.should == "completed"
+            payment.reload
+            payment.state.should == "completed"
 
-            # Ensure that a credit payment was created, and it has correct credit amount
+            # Ensur that a credit payment was created, and it has correct credit amount
             credit_payment = Payment.where(:source_type => 'Spree::Payment', :source_id => payment.id).last
             credit_payment.amount.to_f.should == -45.75
           end
 
-          context "crediting fails" do
-            it "returns a 422 status" do
-              fake_response = double(:success? => false, :to_s => "NO CREDIT FOR YOU")
-              Spree::Gateway::Bogus.any_instance.should_receive(:credit).and_return(fake_response)
-              api_put :credit, :id => payment.to_param
-              response.status.should == 422
-              json_response["error"].should == "There was a problem with the payment gateway: NO CREDIT FOR YOU"
-            end
-
-            it "cannot credit over credit_allowed limit" do
-              api_put :credit, :id => payment.to_param, :amount => 1000000
-              response.status.should == 422
-              json_response["error"].should == "This payment can only be credited up to 45.75. Please specify an amount less than or equal to this number."
-            end
+          it "returns a 422 status when crediting fails" do
+            fake_response = double(:success? => false, :to_s => "NO CREDIT FOR YOU")
+            Spree::Gateway::Bogus.any_instance.should_receive(:credit).and_return(fake_response)
+            api_put :credit, :id => payment.to_param
+            response.status.should == 422
+            json_response["error"].should == "There was a problem with the payment gateway: NO CREDIT FOR YOU"
+          end
+
+          it "cannot credit over credit_allowed limit" do
+            api_put :credit, :id => payment.to_param, :amount => 1000000
+            response.status.should == 422
+            json_response["error"].should == "This payment can only be credited up to 45.75. Please specify an amount less than or equal to this number."
           end
         end
       end
+
     end
+
   end
 end

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

@@ -7,22 +7,7 @@ module Spree
 
     let!(:product) { create(:product) }
     let!(:inactive_product) { create(:product, :available_on => Time.now.tomorrow, :name => "inactive") }
-    let(:attributes) { [:id, :name, :description, :price, :available_on, :permalink, :meta_description, :meta_keywords, :shipping_category_id, :taxon_ids] }
-    let(:product_hash) do
-      { :name => "The Other Product",
-        :price => 19.99,
-        :shipping_category_id => create(:shipping_category).id }
-    end
-    let(:attributes_for_variant) do
-      h = attributes_for(:variant).except(:is_master, :product)
-      h.delete(:option_values)
-      h.merge({
-        options: [
-          { name: "size", value: "small" },
-          { name: "color", value: "black" }
-        ]
-      })
-    end
+    let(:attributes) { [:id, :name, :description, :price, :display_price, :available_on, :permalink, :meta_description, :meta_keywords, :shipping_category_id, :taxon_ids] }
 
     before do
       stub_authentication!
@@ -32,25 +17,16 @@ module Spree
       it "retrieves a list of products" do
         api_get :index
         json_response["products"].first.should have_attributes(attributes)
-        json_response["count"].should == 1
+        json_response["total_count"].should == 1
         json_response["current_page"].should == 1
         json_response["pages"].should == 1
+        json_response["per_page"].should == Kaminari.config.default_per_page
       end
 
       it "retrieves a list of products by id" do
         api_get :index, :ids => [product.id]
         json_response["products"].first.should have_attributes(attributes)
-        json_response["count"].should == 1
-        json_response["current_page"].should == 1
-        json_response["pages"].should == 1
-      end
-
-      it "retrieves a list of products by ids string" do
-        second_product = create(:product)
-        api_get :index, :ids => [product.id, second_product.id].join(",")
-        json_response["products"].first.should have_attributes(attributes)
-        json_response["products"][1].should have_attributes(attributes)
-        json_response["total_count"].should == 2
+        json_response["total_count"].should == 1
         json_response["current_page"].should == 1
         json_response["pages"].should == 1
         json_response["per_page"].should == Kaminari.config.default_per_page
@@ -92,13 +68,6 @@ module Spree
           response.body.should =~ /^callback\(.*\)$/
           response.header['Content-Type'].should include('application/javascript')
         end
-
-        # Regression test for #4332
-        it "does not escape quotes" do
-          api_get :index, {:callback => 'callback'}
-          response.body.should =~ /^callback\({"count":1,"total_count":1/
-          response.header['Content-Type'].should include('application/javascript')
-        end
       end
 
       it "can search for products" do
@@ -124,7 +93,10 @@ module Spree
                                                                                 :attachment_width,
                                                                                 :attachment_height,
                                                                                 :attachment_content_type,
-                                                                                :attachment_url])
+                                                                                :mini_url,
+                                                                                :small_url,
+                                                                                :product_url,
+                                                                                :large_url])
 
         json_response["product_properties"].first.should have_attributes([:value,
                                                                          :product_id,
@@ -151,14 +123,12 @@ module Spree
 
       it "cannot see inactive products" do
         api_get :show, :id => inactive_product.to_param
-        json_response["error"].should == "The resource you were looking for could not be found."
-        response.status.should == 404
+        assert_not_found!
       end
 
       it "returns a 404 error when it cannot find a product" do
         api_get :show, :id => "non-existant"
-        json_response["error"].should == "The resource you were looking for could not be found."
-        response.status.should == 404
+        assert_not_found!
       end
 
       it "can learn how to create a new product" do
@@ -202,71 +172,13 @@ module Spree
       end
 
       it "can create a new product" do
-        api_post :create, :product => product_hash
+        api_post :create, :product => { :name => "The Other Product",
+                                        :price => 19.99,
+                                        :shipping_category_id => create(:shipping_category).id }
         json_response.should have_attributes(attributes)
         response.status.should == 201
       end
 
-      describe "creating products with" do
-        it "embedded variants" do
-          product_hash.merge!({
-            variants_attributes: [
-              attributes_for_variant,
-              attributes_for_variant
-            ]
-          })
-
-          api_post :create, :product => product_hash
-          expect(response.status).to eq 201
-
-          variants = json_response['variants'].select { |v| !v['is_master'] }
-          expect(variants.first['option_values'][0]['name']).to eq('small')
-          expect(variants.first['option_values'][0]['option_type_name']).to eq('size')
-
-          expect(json_response['option_types'].count).to eq(2) # size, color
-        end
-
-        it "embedded product_properties" do
-          product_hash.merge!({
-            shipping_category_id: 1,
-
-            product_properties_attributes: [{
-              property_name: "fabric",
-              value: "cotton"
-            }]
-          })
-
-          api_post :create, :product => product_hash
-
-          expect(json_response['product_properties'][0]['property_name']).to eq('fabric')
-          expect(json_response['product_properties'][0]['value']).to eq('cotton')
-        end
-
-        it "option_types even if without variants" do
-          product_hash.merge!({
-            shipping_category_id: 1,
-
-            option_types: ['size', 'color']
-          })
-
-          api_post :create, :product => product_hash
-
-          expect(json_response['option_types'].count).to eq(2)
-        end
-
-        it "creates with shipping categories" do
-          hash = { :name => "The Other Product",
-                   :price => 19.99,
-                   :shipping_category => "Free Ships" }
-
-          api_post :create, :product => hash
-          expect(response.status).to eq 201
-
-          shipping_id = ShippingCategory.find_by_name("Free Ships").id
-          expect(json_response['shipping_category_id']).to eq shipping_id
-        end
-      end
-
       # Regression test for #2140
       context "with authentication_required set to false" do
         before do
@@ -301,13 +213,6 @@ module Spree
         response.status.should == 200
       end
 
-      it "updates shipping category properly if provided" do
-        api_put :update, :id => product.to_param, :product => { :shipping_category => "New Ships" }
-        expect(response.status).to eq 200
-        shipping_id = ShippingCategory.find_by_name("New Ships").id
-        expect(json_response['shipping_category_id']).to eq shipping_id
-      end
-
       it "cannot update a product with an invalid attribute" do
         api_put :update, :id => product.to_param, :product => { :name => "" }
         response.status.should == 422
@@ -321,41 +226,6 @@ module Spree
         response.status.should == 204
         product.reload.deleted_at.should_not be_nil
       end
-
-      describe "updating products with" do
-        it "embedded option types" do
-          api_put :update, :id => product.to_param, :product => { :option_types => ['shape', 'color'] }
-          json_response['option_types'].count.should eq(2)
-        end
-
-        it "new variants" do
-          api_put :update, :id => product.to_param, :product => { :variants_attributes => [attributes_for_variant, attributes_for_variant] }
-          response.status.should == 200
-          json_response['variants'].count.should == 3 # 1 master + 2 variants
-
-          variants = json_response['variants'].select { |v| !v['is_master'] }
-          variants.last['option_values'][0]['name'].should == 'small'
-          variants.last['option_values'][0]['option_type_name'].should == 'size'
-
-          json_response['option_types'].count.should == 2 # size, color
-        end
-
-        it "updating an existing variant" do
-          variant_hash = {
-            :sku => '123', :price => 19.99, :options => [{:name => "size", :value => "small"}]
-          }
-          variant = product.variants.new
-          variant.update_attributes(variant_hash)
-
-          api_put :update, :id => product.to_param, :product => { :variants_attributes => [variant_hash.merge(:id => variant.id.to_s, :sku => '456', :options => [{:name => "size", :value => "large" }])] }
-
-          json_response['variants'].count.should == 2 # 1 master + 2 variants
-          variants = json_response['variants'].select { |v| !v['is_master'] }
-          variants.last['option_values'][0]['name'].should == 'large'
-          variants.last['sku'].should == '456'
-          variants.count.should == 1
-        end
-      end
     end
   end
 end

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

@@ -41,27 +41,12 @@ module Spree
 
       it "cannot update a return authorization" do
         api_put :update
-        assert_unauthorized!
-      end
-
-      it "cannot add a variant to a return authorization" do
-        api_put :add
-        assert_unauthorized!
-      end
-
-      it "cannot mark a return authorization as received" do
-        api_put :receive
-        assert_unauthorized!
-      end
-
-      it "cannot cancel a return authorization" do
-        api_put :cancel
-        assert_unauthorized!
+        assert_not_found!
       end
 
       it "cannot delete a return authorization" do
         api_delete :destroy
-        assert_unauthorized!
+        assert_not_found!
       end
     end
 
@@ -133,7 +118,7 @@ module Spree
       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)
+        FactoryGirl.create(:new_return_authorization, :order => order)
         return_authorization = order.return_authorizations.first
         return_authorization.state.should == "authorized"
 
@@ -176,7 +161,7 @@ module Spree
       end
 
       it "can add a new return authorization to an existing order" do
-        api_post :create, :return_autorization => { :order_id => order.number, :amount => 14.22, :reason => "Defective" }
+        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

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 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_method, :inventory_units] }
+  let!(:attributes) { [:id, :tracking, :number, :cost, :shipped_at, :stock_location_name, :order_id, :shipping_rates, :shipping_methods] }
 
   before do
     stub_authentication!
@@ -96,7 +96,7 @@ 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['inventory_units'].select { |h| h['variant_id'] == variant.id }.size.should == 2
+        json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"].should == 2
       end
 
       it 'removes a variant from a shipment' do
@@ -104,7 +104,7 @@ describe Spree::Api::ShipmentsController do
 
         api_put :remove, { variant_id: variant.to_param, quantity: 1 }
         response.status.should == 200
-        json_response['inventory_units'].select { |h| h['variant_id'] == variant.id }.size.should == 1
+        json_response['manifest'].detect { |h| h['variant']['id'] == variant.id }["quantity"].should == 1
      end
     end
 

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

@@ -19,7 +19,7 @@ module Spree
 
     context "pagination" do
       before do
-        State.should_receive(:scoped).and_return(@scope = double)
+        State.should_receive(:accessible_by).and_return(@scope = double)
         @scope.stub_chain(:ransack, :result, :includes, :order).and_return(@scope)
       end