spree_api 2.2.14 → 2.3.0

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

@@ -21,31 +21,6 @@ module Spree
       Spree::Config[:track_inventory_levels] = true
     end
 
-    context "GET 'show'" do
-      let(:order) { create(:order) }
-
-      it "redirects to Orders#show" do
-        api_get :show, :id => order.number
-        response.status.should == 301
-        response.should redirect_to("/api/orders/#{order.number}")
-      end
-    end
-
-    context "POST 'create'" do
-      it "creates a new order when no parameters are passed" do
-        api_post :create
-
-        json_response['number'].should be_present
-        response.status.should == 201
-      end
-
-      it "assigns email when creating a new order" do
-        api_post :create, :order => { :email => "guest@spreecommerce.com" }
-        expect(json_response['email']).not_to eq controller.current_api_user
-        expect(json_response['email']).to eq "guest@spreecommerce.com"
-      end
-    end
-
     context "PUT 'update'" do
       let(:order) do
         order = create(:order_with_line_items)
@@ -60,41 +35,24 @@ module Spree
         Order.any_instance.stub(:payment_required? => true)
       end
 
-      it 'should not allow users to change the price of line items' do
-        line_item = order.line_items.first
-        price_was = line_item.price
-        api_put(
-          :update,
-          id: order.to_param,
-          order_token: order.token,
-          order: {
-            line_items: {0 => {id: line_item.id, price: '0.1', quantity: '3'}}
-          }
-        )
-        response.status.should == 200
-        line_item.reload
-        expect(line_item.price).to eq price_was
-        expect(line_item.price).to_not eq 0.1
-      end
-
       it "should transition a recently created order from cart to address" do
         order.state.should eq "cart"
         order.email.should_not be_nil
-        api_put :update, :id => order.to_param, :order_token => order.token
+        api_put :update, :id => order.to_param, :order_token => order.guest_token
         order.reload.state.should eq "address"
       end
 
       it "should transition a recently created order from cart to address with order token in header" do
         order.state.should eq "cart"
         order.email.should_not be_nil
-        request.headers["X-Spree-Order-Token"] = order.token
+        request.headers["X-Spree-Order-Token"] = order.guest_token
         api_put :update, :id => order.to_param
         order.reload.state.should eq "address"
       end
 
       it "can take line_items_attributes as a parameter" do
         line_item = order.line_items.first
-        api_put :update, :id => order.to_param, :order_token => order.token,
+        api_put :update, :id => order.to_param, :order_token => order.guest_token,
                          :order => { :line_items_attributes => { 0 => { :id => line_item.id, :quantity => 1 } } }
         response.status.should == 200
         order.reload.state.should eq "address"
@@ -102,41 +60,66 @@ module Spree
 
       it "can take line_items as a parameter" do
         line_item = order.line_items.first
-        api_put :update, :id => order.to_param, :order_token => order.token,
+        api_put :update, :id => order.to_param, :order_token => order.guest_token,
                          :order => { :line_items => { 0 => { :id => line_item.id, :quantity => 1 } } }
         response.status.should == 200
         order.reload.state.should eq "address"
       end
 
       it "will return an error if the order cannot transition" do
-        skip "not sure if this test is valid"
+        pending "not sure if this test is valid"
         order.bill_address = nil
         order.save
         order.update_column(:state, "address")
-        api_put :update, :id => order.to_param, :order_token => order.token
+        api_put :update, :id => order.to_param, :order_token => order.guest_token
         # Order has not transitioned
         response.status.should == 422
       end
 
-      it "can update addresses and transition from address to delivery" do
-        order.update_column(:state, "address")
-        shipping_address = billing_address = {
-          :firstname  => 'John',
-          :lastname   => 'Doe',
-          :address1   => '7735 Old Georgetown Road',
-          :city       => 'Bethesda',
-          :phone      => '3014445002',
-          :zipcode    => '20814',
-          :state_id   => @state.id,
-          :country_id => @country.id
-        }
-        api_put :update,
-                :id => order.to_param, :order_token => order.token,
-                :order => { :bill_address_attributes => billing_address, :ship_address_attributes => shipping_address }
-        json_response['state'].should == 'delivery'
-        json_response['bill_address']['firstname'].should == 'John'
-        json_response['ship_address']['firstname'].should == 'John'
-        response.status.should == 200
+      context "transitioning to delivery" do
+        before do
+          order.update_column(:state, "address")
+        end
+
+        let(:address) do
+          {
+            :firstname  => 'John',
+            :lastname   => 'Doe',
+            :address1   => '7735 Old Georgetown Road',
+            :city       => 'Bethesda',
+            :phone      => '3014445002',
+            :zipcode    => '20814',
+            :state_id   => @state.id,
+            :country_id => @country.id
+          }
+        end
+
+        it "can update addresses and transition from address to delivery" do
+          api_put :update,
+                  :id => order.to_param, :order_token => order.guest_token,
+                  :order => {
+                    :bill_address_attributes => address,
+                    :ship_address_attributes => address
+                  }
+          json_response['state'].should == 'delivery'
+          json_response['bill_address']['firstname'].should == 'John'
+          json_response['ship_address']['firstname'].should == 'John'
+          response.status.should == 200
+        end
+
+        # Regression test for #4498
+        it "does not contain duplicate variant data in delivery return" do
+          api_put :update,
+                  :id => order.to_param, :order_token => order.guest_token,
+                  :order => {
+                    :bill_address_attributes => address,
+                    :ship_address_attributes => address
+                  }
+          # Shipments manifests should not return the ENTIRE variant
+          # This information is already present within the order's line items
+          expect(json_response['shipments'].first['manifest'].first['variant']).to be_nil
+          expect(json_response['shipments'].first['manifest'].first['variant_id']).to_not be_nil
+        end
       end
 
       it "can update shipping method and transition from delivery to payment" do
@@ -144,7 +127,7 @@ module Spree
         shipment = create(:shipment, :order => order)
         shipment.refresh_rates
         shipping_rate = shipment.shipping_rates.where(:selected => false).first
-        api_put :update, :id => order.to_param, :order_token => order.token,
+        api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => { :shipments_attributes => { "0" => { :selected_shipping_rate_id => shipping_rate.id, :id => shipment.id } } }
         response.status.should == 200
         # Find the correct shipment...
@@ -152,14 +135,14 @@ module Spree
         # Find the correct shipping rate for that shipment...
         json_shipping_rate = json_shipment['shipping_rates'].detect { |sr| sr["id"] == shipping_rate.id }
         # ... And finally ensure that it's selected
-        json_shipping_rate['selected'].should be true
+        json_shipping_rate['selected'].should be_true
         # Order should automatically transfer to payment because all criteria are met
         json_response['state'].should == 'payment'
       end
 
       it "can update payment method and transition from payment to confirm" do
         order.update_column(:state, "payment")
-        api_put :update, :id => order.to_param, :order_token => order.token,
+        api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => { :payments_attributes => [{ :payment_method_id => @payment_method.id }] }
         json_response['state'].should == 'confirm'
         json_response['payments'][0]['payment_method']['name'].should == @payment_method.name
@@ -177,7 +160,7 @@ module Spree
           "name" => "Spree Commerce"
         }
 
-        api_put :update, :id => order.to_param, :order_token => order.token,
+        api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => { :payments_attributes => [{ :payment_method_id => @payment_method.id.to_s }],
                       :payment_source => { @payment_method.id.to_s => source_attributes } }
         json_response['payments'][0]['payment_method']['name'].should == @payment_method.name
@@ -187,9 +170,13 @@ module Spree
 
       it "returns errors when source is missing attributes" do
         order.update_column(:state, "payment")
-        api_put :update, :id => order.to_param, :order_token => order.token,
-          :order => { :payments_attributes => [{ :payment_method_id => @payment_method.id.to_s }],
-                      :payment_source => { @payment_method.id.to_s => { name: "Spree" } } }
+        api_put :update, :id => order.to_param, :order_token => order.guest_token,
+          :order => {
+            :payments_attributes => [{ :payment_method_id => @payment_method.id.to_s }]
+          },
+          :payment_source => {
+            @payment_method.id.to_s => { name: "Spree" }
+          }
 
         response.status.should == 422
         cc_errors = json_response['errors']['payments.Credit Card']
@@ -202,14 +189,14 @@ module Spree
       it "can transition from confirm to complete" do
         order.update_column(:state, "confirm")
         Spree::Order.any_instance.stub(:payment_required? => false)
-        api_put :update, :id => order.to_param, :order_token => order.token
+        api_put :update, :id => order.to_param, :order_token => order.guest_token
         json_response['state'].should == 'complete'
         response.status.should == 200
       end
 
       it "returns the order if the order is already complete" do
         order.update_column(:state, "complete")
-        api_put :update, :id => order.to_param, :order_token => order.token
+        api_put :update, :id => order.to_param, :order_token => order.guest_token
         json_response['number'].should == order.number
         response.status.should == 200
       end
@@ -217,7 +204,7 @@ module Spree
       # Regression test for #3784
       it "can update the special instructions for an order" do
         instructions = "Don't drop it. (Please)"
-        api_put :update, :id => order.to_param, :order_token => order.token,
+        api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => { :special_instructions => instructions }
         expect(json_response['special_instructions']).to eql(instructions)
       end
@@ -227,7 +214,7 @@ module Spree
         it "can assign a user to the order" do
           user = create(:user)
           # Need to pass email as well so that validations succeed
-          api_put :update, :id => order.to_param, :order_token => order.token,
+          api_put :update, :id => order.to_param, :order_token => order.guest_token,
             :order => { :user_id => user.id, :email => "guest@spreecommerce.com" }
           response.status.should == 200
           json_response['user_id'].should == user.id
@@ -235,19 +222,19 @@ module Spree
       end
 
       it "can assign an email to the order" do
-        api_put :update, :id => order.to_param, :order_token => order.token,
+        api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => { :email => "guest@spreecommerce.com" }
         json_response['email'].should == "guest@spreecommerce.com"
         response.status.should == 200
       end
 
       it "can apply a coupon code to an order" do
-        skip "ensure that the order totals are properly updated, see frontend orders_controller or checkout_controller as example"
+        pending "ensure that the order totals are properly updated, see frontend orders_controller or checkout_controller as example"
 
         order.update_column(:state, "payment")
         PromotionHandler::Coupon.should_receive(:new).with(order).and_call_original
         PromotionHandler::Coupon.any_instance.should_receive(:apply).and_return({:coupon_applied? => true})
-        api_put :update, :id => order.to_param, :order_token => order.token, :order => { :coupon_code => "foobar" }
+        api_put :update, :id => order.to_param, :order_token => order.guest_token, :order => { :coupon_code => "foobar" }
       end
     end
 
@@ -256,7 +243,7 @@ module Spree
       it "cannot transition to address without a line item" do
         order.line_items.delete_all
         order.update_column(:email, "spree@example.com")
-        api_put :next, :id => order.to_param, :order_token => order.token
+        api_put :next, :id => order.to_param, :order_token => order.guest_token
         response.status.should == 422
         json_response["errors"]["base"].should include(Spree.t(:there_are_no_items_for_this_order))
       end
@@ -264,7 +251,7 @@ module Spree
       it "can transition an order to the next state" do
         order.update_column(:email, "spree@example.com")
 
-        api_put :next, :id => order.to_param, :order_token => order.token
+        api_put :next, :id => order.to_param, :order_token => order.guest_token
         response.status.should == 200
         json_response['state'].should == 'address'
       end
@@ -275,29 +262,30 @@ module Spree
           email: nil
         )
 
-        api_put :next, :id => order.to_param, :order_token => order.token
+        api_put :next, :id => order.to_param, :order_token => order.guest_token
         response.status.should == 422
         json_response['error'].should =~ /could not be transitioned/
       end
 
-      it "returns a sensible error when no payment method is specified" do
+      it "doesnt advance payment state if order has no payment" do
         order.update_column(:state, "payment")
-        api_put :next, :id => order.to_param, :order_token => order.token, :order => {}
-        json_response["errors"]["base"].should include(Spree.t(:no_pending_payments))
+        api_put :next, :id => order.to_param, :order_token => order.guest_token, :order => {}
+        json_response["errors"]["base"].should include(Spree.t(:no_payment_found))
       end
     end
 
     context "PUT 'advance'" do
       let!(:order) { create(:order_with_line_items) }
+
       it 'continues to advance advances an order while it can move forward' do
         Spree::Order.any_instance.should_receive(:next).exactly(3).times.and_return(true, true, false)
-        api_put :advance, :id => order.to_param, :order_token => order.token
+        api_put :advance, :id => order.to_param, :order_token => order.guest_token
       end
+
       it 'returns the order' do
-        api_put :advance, :id => order.to_param, :order_token => order.token
+        api_put :advance, :id => order.to_param, :order_token => order.guest_token
         json_response['id'].should == order.id
       end
-
     end
   end
 end

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

@@ -10,11 +10,8 @@ module Spree
     let(:attributes) { [:id, :quantity, :price, :variant, :total, :display_amount, :single_display_amount] }
     let(:resource_scoping) { { :order_id => order.to_param } }
 
-    before do
-      stub_authentication!
-    end
-
     it "can learn how to create a new line item" do
+      controller.stub :try_spree_current_user => current_api_user
       api_get :new
       json_response["attributes"].should == ["quantity", "price", "variant_id"]
       required_attributes = json_response["required_attributes"]
@@ -23,14 +20,14 @@ module Spree
 
     context "authenticating with a token" do
       it "can add a new line item to an existing order" do
-        api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }, :order_token => order.token
+        api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }, :order_token => order.guest_token
         response.status.should == 201
         json_response.should have_attributes(attributes)
         json_response["variant"]["name"].should_not be_blank
       end
 
       it "can add a new line item to an existing order with token in header" do
-        request.headers["X-Spree-Order-Token"] = order.token
+        request.headers["X-Spree-Order-Token"] = order.guest_token
         api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }
         response.status.should == 201
         json_response.should have_attributes(attributes)
@@ -40,7 +37,8 @@ module Spree
 
     context "as the order owner" do
       before do
-        allow_any_instance_of(Order).to receive_messages :user => current_api_user
+        controller.stub :try_spree_current_user => current_api_user
+        Order.any_instance.stub :user => current_api_user
       end
 
       it "can add a new line item to an existing order" do
@@ -50,6 +48,13 @@ module Spree
         json_response["variant"]["name"].should_not be_blank
       end
 
+      it "default quantity to 1 if none is given" do
+        api_post :create, :line_item => { :variant_id => product.master.to_param }
+        response.status.should == 201
+        json_response.should have_attributes(attributes)
+        expect(json_response[:quantity]).to eq 1
+      end
+
       it "increases a line item's quantity if it exists already" do
         order.line_items.create(:variant_id => product.master.id, :quantity => 10)
         api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }
@@ -121,8 +126,7 @@ module Spree
     context "as just another user" do
       before do
         user = create(:user)
-        allow(Spree.user_class).to receive(:find_by).
-                                     and_return(user)
+        controller.stub :try_spree_current_user => user
       end
 
       it "cannot add a new line item to the order" do

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

@@ -26,8 +26,6 @@ module Spree
                                :city => "Sao Paulo", :zipcode => "1234567", :phone => "12345678",
                                :country_id => Country.first.id, :state_id => State.first.id} }
 
-    let!(:payment_method) { create(:check_payment_method) }
-
     let(:current_api_user) do
       user = Spree.user_class.new(:email => "spree@example.com")
       user.generate_spree_api_key!
@@ -75,18 +73,6 @@ module Spree
         response.status.should == 200
         json_response["orders"].length.should == 0
       end
-
-      it "returns orders in reverse chronological order" do
-        order2 = create(:order, line_items: [line_item], user: order.user)
-        order2.created_at.should > order.created_at
-
-        api_get :mine
-        response.status.should == 200
-        json_response["pages"].should == 1
-        json_response["orders"].length.should == 2
-        json_response["orders"][0]["number"].should == order2.number
-        json_response["orders"][1]["number"].should == order.number
-      end
     end
 
     it "can view their own order" do
@@ -95,7 +81,6 @@ module Spree
       response.status.should == 200
       json_response.should have_attributes(attributes)
       json_response["adjustments"].should be_empty
-      json_response["credit_cards"].should be_empty
     end
 
     it "orders contain the basic checkout steps" do
@@ -119,12 +104,12 @@ module Spree
     end
 
     it "can view an order if the token is known" do
-      api_get :show, :id => order.to_param, :order_token => order.token
+      api_get :show, :id => order.to_param, :order_token => order.guest_token
       response.status.should == 200
     end
 
     it "can view an order if the token is passed in header" do
-      request.headers["X-Spree-Order-Token"] = order.token
+      request.headers["X-Spree-Order-Token"] = order.guest_token
       api_get :show, :id => order.to_param
       response.status.should == 200
     end
@@ -135,10 +120,9 @@ module Spree
 
       it "can view an order" do
         user = mock_model(Spree::LegacyUser)
-        allow(user).to receive_message_chain(:spree_roles, :pluck).and_return(["bar"])
-        allow(user).to receive(:has_spree_role?).with('bar').and_return(true)
-        allow(user).to receive(:has_spree_role?).with('admin').and_return(false)
-        allow(Spree.user_class).to receive_messages find_by: user
+        user.stub(:has_spree_role?).with('bar').and_return(true)
+        user.stub(:has_spree_role?).with('admin').and_return(false)
+        controller.stub try_spree_current_user: user
         api_get :show, :id => order.to_param
         response.status.should == 200
       end
@@ -159,10 +143,13 @@ module Spree
     it "can create an order" do
       api_post :create, :order => { :line_items => { "0" => { :variant_id => variant.to_param, :quantity => 5 } } }
       response.status.should == 201
+
       order = Order.last
       order.line_items.count.should == 1
       order.line_items.first.variant.should == variant
       order.line_items.first.quantity.should == 5
+
+      json_response['number'].should be_present
       json_response["token"].should_not be_blank
       json_response["state"].should == "cart"
       order.user.should == current_api_user
@@ -170,12 +157,18 @@ module Spree
       json_response["user_id"].should == current_api_user.id
     end
 
+    it "assigns email when creating a new order" do
+      api_post :create, :order => { :email => "guest@spreecommerce.com" }
+      expect(json_response['email']).not_to eq controller.current_api_user
+      expect(json_response['email']).to eq "guest@spreecommerce.com"
+    end
+
     # Regression test for #3404
     it "can specify additional parameters for a line item" do
       Order.should_receive(:create!).and_return(order = Spree::Order.new)
       order.stub(:associate_user!)
       order.stub_chain(:contents, :add).and_return(line_item = double('LineItem'))
-      line_item.should_receive(:update_attributes!).with("special" => true)
+      line_item.should_receive(:update_attributes).with("special" => true)
 
       controller.stub(permitted_line_item_attributes: [:id, :variant_id, :quantity, :special])
       api_post :create, :order => {
@@ -274,7 +267,7 @@ module Spree
       it "updates quantities of existing line items" do
         api_put :update, :id => order.to_param, :order => {
           :line_items => {
-            0 => { :id => line_item.id, :quantity => 10 }
+            "0" => { :id => line_item.id, :quantity => 10 }
           }
         }
 
@@ -287,8 +280,8 @@ module Spree
         variant2 = create(:variant)
         api_put :update, :id => order.to_param, :order => {
           :line_items => {
-            0 => { :id => line_item.id, :quantity => 10 },
-            1 => { :variant_id => variant2.id, :quantity => 1}
+            "0" => { :id => line_item.id, :quantity => 10 },
+            "1" => { :variant_id => variant2.id, :quantity => 1}
           }
         }
 
@@ -347,6 +340,14 @@ module Spree
         json_response['errors']['ship_address.firstname'].first.should eq "can't be blank"
       end
 
+      it "cannot set the user_id for the order" do
+        user = Spree.user_class.create
+        original_id = order.user_id
+        api_post :update, :id => order.to_param, :order => { user_id: user.id }
+        expect(response.status).to eq 200
+        json_response["user_id"].should == original_id
+      end
+
       context "order has shipments" do
         before { order.create_proposed_shipments }
 
@@ -413,6 +414,18 @@ module Spree
           adjustment['amount'].should == "5.0"
         end
 
+        it "lists payments source" do
+          order.payments.push payment = create(:payment)
+          api_get :show, :id => order.to_param
+
+          source = json_response[:payments].first[:source]
+          expect(source[:name]).to eq payment.source.name
+          expect(source[:cc_type]).to eq payment.source.cc_type
+          expect(source[:last_digits]).to eq payment.source.last_digits
+          expect(source[:month].to_i).to eq payment.source.month
+          expect(source[:year].to_i).to eq payment.source.year
+        end
+
         context "when in delivery" do
           let!(:shipping_method) do
             FactoryGirl.create(:shipping_method).tap do |shipping_method|
@@ -454,13 +467,13 @@ module Spree
             shipping_rate = shipment["shipping_rates"][0]
             shipping_rate["name"].should == json_shipping_method["name"]
             shipping_rate["cost"].should == "10.0"
-            shipping_rate["selected"].should be true
+            shipping_rate["selected"].should be_true
             shipping_rate["display_cost"].should == "$10.00"
 
             shipment["stock_location_name"].should_not be_blank
             manifest_item = shipment["manifest"][0]
             manifest_item["quantity"].should == 1
-            manifest_item["variant"].should have_attributes([:id, :name, :sku, :price])
+            manifest_item["variant_id"].should == order.line_items.first.variant_id
           end
         end
       end
@@ -479,9 +492,9 @@ module Spree
 
       it "responds with orders updated_at with miliseconds precision" do
         if ActiveRecord::Base.connection.adapter_name == "Mysql2"
-          skip "MySQL does not support millisecond timestamps."
+          pending "MySQL does not support millisecond timestamps."
         else
-          skip "Probable need to make it call as_json. See https://github.com/rails/rails/commit/0f33d70e89991711ff8b3dde134a61f4a5a0ec06"
+          pending "Probable need to make it call as_json. See https://github.com/rails/rails/commit/0f33d70e89991711ff8b3dde134a61f4a5a0ec06"
         end
 
         api_get :index
@@ -499,9 +512,9 @@ module Spree
         it "returns unique orders" do
           api_get :index
 
-          orders = json_response["orders"]
+          orders = json_response[:orders]
           expect(orders.count).to be >= 3
-          expect(orders.map { |o| o["id"] }.sort).to eq(Order.order(:id).pluck(:id))
+          expect(orders.map { |o| o[:id] }).to match_array Order.pluck(:id)
         end
 
         after { ActionController::Base.perform_caching = false }
@@ -563,6 +576,15 @@ module Spree
         end
       end
 
+      context "updating" do
+        it "can set the user_id for the order" do
+          user = Spree.user_class.create
+          api_post :update, :id => order.number, :order => { user_id: user.id }
+          expect(response.status).to eq 200
+          json_response["user_id"].should == user.id
+        end
+      end
+
       context "can cancel an order" do
         before do
           Spree::Config[:mails_from] = "spree@example.com"

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

@@ -6,7 +6,7 @@ module Spree
     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,
+                         :payment_method_id, :response_code, :state, :avs_response,
                          :created_at, :updated_at] }
 
     let(:resource_scoping) { { :order_id => order.to_param } }
@@ -64,11 +64,6 @@ module Spree
           api_get :index, :order_id => order.to_param
           assert_unauthorized!
         end
-
-        it "can view the payments for an order given the order token" do
-          api_get :index, :order_id => order.to_param, :order_token => order.token
-          json_response["payments"].first.should have_attributes(attributes)
-        end
       end
     end
 
@@ -82,7 +77,7 @@ module Spree
       end
 
       context "multiple payments" do
-        before { @payment = create(:payment, :order => order) }
+        before { @payment = create(:payment, :order => order, :response_code => '99999') }
 
         it "can view all payments on an order" do
           api_get :index
@@ -95,6 +90,12 @@ module Spree
           json_response['current_page'].should == 1
           json_response['pages'].should == 2
         end
+
+        it 'can query the results through a paramter' do
+          api_get :index, :q => { :response_code_cont => '999' }
+          json_response['count'].should == 1
+          json_response['payments'].first['response_code'].should eq @payment.response_code
+        end
       end
 
       context "for a given payment" do
@@ -143,7 +144,7 @@ module Spree
             end
 
             it "does not raise a stack level error" do
-              skip "Investigate why a payment.reload after the request raises 'stack level too deep'"
+              pending "Investigate why a payment.reload after the request raises 'stack level too deep'"
               payment.reload.state.should == "failed"
             end
           end

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

@@ -169,7 +169,7 @@ module Spree
       context "tracking is disabled" do
         before { Config.track_inventory_levels = false }
 
-        it "still displays valid json with total on hand" do
+        it "still displays valid json with total_on_hand Float::INFINITY" do
           api_get :show, :id => product.to_param
           expect(response).to be_ok
           expect(json_response[:total_on_hand]).to eq nil