spree_api 2.3.13 → 2.4.0.rc1

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

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::PaymentsController, :type => :controller do
+  describe Spree::Api::PaymentsController do
     render_views
     let!(:order) { create(:order) }
     let!(:payment) { create(:payment, :order => order) }
     let!(:attributes) { [:id, :source_type, :source_id, :amount, :display_amount,
-                         :payment_method_id, :state, :avs_response,
+                         :payment_method_id, :response_code, :state, :avs_response,
                          :created_at, :updated_at] }
 
     let(:resource_scoping) { { :order_id => order.to_param } }
@@ -18,30 +18,30 @@ module Spree
     context "as a user" do
       context "when the order belongs to the user" 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 "can view the payments for their order" do
           api_get :index
-          expect(json_response["payments"].first).to have_attributes(attributes)
+          json_response["payments"].first.should have_attributes(attributes)
         end
 
         it "can learn how to create a new payment" do
           api_get :new
-          expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
-          expect(json_response["payment_methods"]).not_to be_empty
-          expect(json_response["payment_methods"].first).to have_attributes([:id, :name, :description])
+          json_response["attributes"].should == attributes.map(&:to_s)
+          json_response["payment_methods"].should_not be_empty
+          json_response["payment_methods"].first.should have_attributes([:id, :name, :description])
         end
 
         it "can create a new payment" do
           api_post :create, :payment => { :payment_method_id => PaymentMethod.first.id, :amount => 50 }
-          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 view a pre-existing payment's details" do
           api_get :show, :id => payment.to_param
-          expect(json_response).to have_attributes(attributes)
+          json_response.should have_attributes(attributes)
         end
 
         it "cannot update a payment" do
@@ -57,7 +57,7 @@ module Spree
 
       context "when the order does not belong to the user" do
         before do
-          allow_any_instance_of(Order).to receive_messages :user => stub_model(LegacyUser)
+          Order.any_instance.stub :user => stub_model(LegacyUser)
         end
 
         it "cannot view payments for somebody else's order" do
@@ -67,7 +67,7 @@ module Spree
 
         it "can view the payments for an order given the order token" do
           api_get :index, :order_id => order.to_param, :order_token => order.guest_token
-          expect(json_response["payments"].first).to have_attributes(attributes)
+          json_response["payments"].first.should have_attributes(attributes)
         end
       end
     end
@@ -77,59 +77,54 @@ module Spree
 
       it "can view the payments on any order" do
         api_get :index
-        expect(response.status).to eq(200)
-        expect(json_response["payments"].first).to have_attributes(attributes)
+        response.status.should == 200
+        json_response["payments"].first.should have_attributes(attributes)
       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
-          expect(json_response["count"]).to eq(2)
+          json_response["count"].should == 2
         end
 
         it 'can control the page size through a parameter' do
           api_get :index, :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
+          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
         context "updating" do
-          context "when the state is checkout" do
-            it "can update" do
-              payment.update_attributes(state: 'checkout')
-              api_put(:update, id: payment.to_param, payment: { amount: 2.01 })
-              expect(response.status).to be(200)
-              expect(payment.reload.amount).to eq(2.01)
-            end
-          end
-
-          context "when the state is pending" do
-            it "can update" do
-              payment.update_attributes(state: 'pending')
-              api_put(:update, id: payment.to_param, payment: { amount: 2.01 })
-              expect(response.status).to be(200)
-              expect(payment.reload.amount).to eq(2.01)
-            end
+          it "can update" do
+            payment.update_attributes(: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_attributes(state: 'pending')
-              api_put(:update, id: payment.to_param, payment: { amount: 'invalid' })
-              expect(response.status).to be(422)
-              expect(json_response['error']).to eql('Invalid resource. Please fix errors and try again.')
+              payment.update_attributes(: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_attributes(state: 'completed')
-              api_put(:update, id: payment.to_param, payment: { amount: 2.01 })
-              expect(response.status).to be(403)
-              expect(json_response['error']).to eql('This payment cannot be updated because it is completed.')
+              payment.update_attributes(:state => 'completed')
+              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 completed."
             end
           end
         end
@@ -137,26 +132,26 @@ module Spree
         context "authorizing" do
           it "can authorize" do
             api_put :authorize, :id => payment.to_param
-            expect(response.status).to eq(200)
-            expect(payment.reload.state).to eq("pending")
+            response.status.should == 200
+            payment.reload.state.should == "pending"
           end
 
           context "authorization fails" do
             before do
               fake_response = double(:success? => false, :to_s => "Could not authorize card")
-              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:authorize).and_return(fake_response)
+              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
-              expect(response.status).to eq(422)
+              response.status.should == 422
               expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
               expect(json_response["errors"]["base"][0]).to eq "Could not authorize card"
             end
 
             it "does not raise a stack level error" do
               skip "Investigate why a payment.reload after the request raises 'stack level too deep'"
-              expect(payment.reload.state).to eq("failed")
+              payment.reload.state.should == "failed"
             end
           end
         end
@@ -164,19 +159,19 @@ module Spree
         context "capturing" do
           it "can capture" do
             api_put :capture, :id => payment.to_param
-            expect(response.status).to eq(200)
-            expect(payment.reload.state).to eq("completed")
+            response.status.should == 200
+            payment.reload.state.should == "completed"
           end
 
           context "capturing fails" do
             before do
               fake_response = double(:success? => false, :to_s => "Insufficient funds")
-              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:capture).and_return(fake_response)
+              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
-              expect(response.status).to eq(422)
+              response.status.should == 422
               expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
               expect(json_response["errors"]["base"][0]).to eq "Insufficient funds"
             end
@@ -186,19 +181,19 @@ module Spree
         context "purchasing" do
           it "can purchase" do
             api_put :purchase, :id => payment.to_param
-            expect(response.status).to eq(200)
-            expect(payment.reload.state).to eq("completed")
+            response.status.should == 200
+            payment.reload.state.should == "completed"
           end
 
           context "purchasing fails" do
             before do
               fake_response = double(:success? => false, :to_s => "Insufficient funds")
-              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:purchase).and_return(fake_response)
+              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
-              expect(response.status).to eq(422)
+              response.status.should == 422
               expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
               expect(json_response["errors"]["base"][0]).to eq "Insufficient funds"
             end
@@ -215,7 +210,7 @@ module Spree
           context "voiding fails" do
             before do
               fake_response = double(success?: false, to_s: "NO REFUNDS")
-              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:void).and_return(fake_response)
+              Spree::Gateway::Bogus.any_instance.should_receive(:void).and_return(fake_response)
             end
 
             it "returns a 422 status" do
@@ -228,38 +223,6 @@ module Spree
           end
         end
 
-        context "crediting" do
-          before do
-            payment.purchase!
-          end
-
-          it "can credit" do
-            api_put :credit, :id => payment.to_param
-            expect(response.status).to eq(200)
-            expect(payment.reload.state).to eq("completed")
-
-            # Ensure 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
-            expect(credit_payment.amount.to_f).to eq(-45.75)
-          end
-
-          context "crediting fails" do
-            it "returns a 422 status" do
-              fake_response = double(:success? => false, :to_s => "NO CREDIT FOR YOU")
-              expect_any_instance_of(Spree::Gateway::Bogus).to receive(:credit).and_return(fake_response)
-              api_put :credit, :id => payment.to_param
-              expect(response.status).to eq(422)
-              expect(json_response["error"]).to eq "Invalid resource. Please fix errors and try again."
-              expect(json_response["errors"]["base"][0]).to eq "NO CREDIT FOR YOU"
-            end
-
-            it "cannot credit over credit_allowed limit" do
-              api_put :credit, :id => payment.to_param, :amount => 1000000
-              expect(response.status).to eq(422)
-              expect(json_response["error"]).to eq("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/product_properties_controller_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'shared_examples/protect_product_actions'
 
 module Spree
-  describe Spree::Api::ProductPropertiesController, :type => :controller do
+  describe Spree::Api::ProductPropertiesController do
     render_views
 
     let!(:product) { create(:product) }
@@ -23,40 +23,40 @@ module Spree
 
       it "can not see a list of product properties" do
         api_get :index
-        expect(response.status).to eq(404)
+        response.status.should == 404
       end
     end
 
     it "can see a list of all product properties" do
       api_get :index
-      expect(json_response["product_properties"].count).to eq 2
-      expect(json_response["product_properties"].first).to have_attributes(attributes)
+      json_response["product_properties"].count.should eq 2
+      json_response["product_properties"].first.should have_attributes(attributes)
     end
 
     it "can control the page size through a parameter" do
       api_get :index, :per_page => 1
-      expect(json_response['product_properties'].count).to eq(1)
-      expect(json_response['current_page']).to eq(1)
-      expect(json_response['pages']).to eq(2)
+      json_response['product_properties'].count.should == 1
+      json_response['current_page'].should == 1
+      json_response['pages'].should == 2
     end
 
     it 'can query the results through a parameter' do
       Spree::ProductProperty.last.update_attribute(:value, 'loose')
       property = Spree::ProductProperty.last
       api_get :index, :q => { :value_cont => 'loose' }
-      expect(json_response['count']).to eq(1)
-      expect(json_response['product_properties'].first['value']).to eq property.value
+      json_response['count'].should == 1
+      json_response['product_properties'].first['value'].should eq property.value
     end
 
     it "can see a single product_property" do
       api_get :show, :id => property_1.property_name
-      expect(json_response).to have_attributes(attributes)
+      json_response.should have_attributes(attributes)
     end
 
     it "can learn how to create a new product property" do
       api_get :new
-      expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
-      expect(json_response["required_attributes"]).to be_empty
+      json_response["attributes"].should == attributes.map(&:to_s)
+      json_response["required_attributes"].should be_empty
     end
 
     it "cannot create a new product property if not an admin" do
@@ -72,7 +72,7 @@ module Spree
     it "cannot delete a product property" do
       api_delete :destroy, :property_name => property_1.property_name
       assert_unauthorized!
-      expect { property_1.reload }.not_to raise_error
+      lambda { property_1.reload }.should_not raise_error
     end
 
     context "as an admin" do
@@ -82,19 +82,19 @@ module Spree
         expect do
           api_post :create, :product_property => { :property_name => "My Property 3", :value => "my value 3" }
         end.to change(product.product_properties, :count).by(1)
-        expect(json_response).to have_attributes(attributes)
-        expect(response.status).to eq(201)
+        json_response.should have_attributes(attributes)
+        response.status.should == 201
       end
 
       it "can update a product property" do
         api_put :update, :id => property_1.property_name, :product_property => { :value => "my value 456" }
-        expect(response.status).to eq(200)
+        response.status.should == 200
       end
 
       it "can delete a product property" do
         api_delete :destroy, :id => property_1.property_name
-        expect(response.status).to eq(204)
-        expect { property_1.reload }.to raise_error(ActiveRecord::RecordNotFound)
+        response.status.should == 204
+        lambda { property_1.reload }.should raise_error(ActiveRecord::RecordNotFound)
       end
     end
 
@@ -102,13 +102,13 @@ module Spree
       let(:resource_scoping) { { :product_id => product.id } }
       it "can see a list of all product properties" do
         api_get :index
-        expect(json_response["product_properties"].count).to eq 2
-        expect(json_response["product_properties"].first).to have_attributes(attributes)
+        json_response["product_properties"].count.should eq 2
+        json_response["product_properties"].first.should have_attributes(attributes)
       end
 
       it "can see a single product_property by id" do
         api_get :show, :id => property_1.id
-        expect(json_response).to have_attributes(attributes)
+        json_response.should have_attributes(attributes)
       end
     end