spree_api 2.3.13 → 2.4.0.rc1

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::CheckoutsController, :type => :controller do
+  describe Api::CheckoutsController do
     render_views
 
     before(:each) do
@@ -31,39 +31,39 @@ module Spree
       end
 
       before(:each) do
-        allow_any_instance_of(Order).to receive_messages(:confirmation_required? => true)
-        allow_any_instance_of(Order).to receive_messages(:payment_required? => true)
+        Order.any_instance.stub(:confirmation_required? => true)
+        Order.any_instance.stub(:payment_required? => true)
       end
 
       it "should transition a recently created order from cart to address" do
-        expect(order.state).to eq "cart"
-        expect(order.email).not_to be_nil
+        order.state.should eq "cart"
+        order.email.should_not be_nil
         api_put :update, :id => order.to_param, :order_token => order.guest_token
-        expect(order.reload.state).to eq "address"
+        order.reload.state.should eq "address"
       end
 
       it "should transition a recently created order from cart to address with order token in header" do
-        expect(order.state).to eq "cart"
-        expect(order.email).not_to be_nil
+        order.state.should eq "cart"
+        order.email.should_not be_nil
         request.headers["X-Spree-Order-Token"] = order.guest_token
         api_put :update, :id => order.to_param
-        expect(order.reload.state).to eq "address"
+        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.guest_token,
                          :order => { :line_items_attributes => { 0 => { :id => line_item.id, :quantity => 1 } } }
-        expect(response.status).to eq(200)
-        expect(order.reload.state).to eq "address"
+        response.status.should == 200
+        order.reload.state.should eq "address"
       end
 
       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.guest_token,
                          :order => { :line_items => { 0 => { :id => line_item.id, :quantity => 1 } } }
-        expect(response.status).to eq(200)
-        expect(order.reload.state).to eq "address"
+        response.status.should == 200
+        order.reload.state.should eq "address"
       end
 
       it "will return an error if the order cannot transition" do
@@ -73,7 +73,7 @@ module Spree
         order.update_column(:state, "address")
         api_put :update, :id => order.to_param, :order_token => order.guest_token
         # Order has not transitioned
-        expect(response.status).to eq(422)
+        response.status.should == 422
       end
 
       context "transitioning to delivery" do
@@ -101,10 +101,10 @@ module Spree
                     :bill_address_attributes => address,
                     :ship_address_attributes => address
                   }
-          expect(json_response['state']).to eq('delivery')
-          expect(json_response['bill_address']['firstname']).to eq('John')
-          expect(json_response['ship_address']['firstname']).to eq('John')
-          expect(response.status).to eq(200)
+          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
@@ -129,25 +129,25 @@ module Spree
         shipping_rate = shipment.shipping_rates.where(:selected => false).first
         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 } } }
-        expect(response.status).to eq(200)
+        response.status.should == 200
         # Find the correct shipment...
         json_shipment = json_response['shipments'].detect { |s| s["id"] == shipment.id }
         # 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
-        expect(json_shipping_rate['selected']).to be true
+        json_shipping_rate['selected'].should be true
         # Order should automatically transfer to payment because all criteria are met
-        expect(json_response['state']).to eq('payment')
+        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.guest_token,
           :order => { :payments_attributes => [{ :payment_method_id => @payment_method.id }] }
-        expect(json_response['state']).to eq('confirm')
-        expect(json_response['payments'][0]['payment_method']['name']).to eq(@payment_method.name)
-        expect(json_response['payments'][0]['amount']).to eq(order.total.to_s)
-        expect(response.status).to eq(200)
+        json_response['state'].should == 'confirm'
+        json_response['payments'][0]['payment_method']['name'].should == @payment_method.name
+        json_response['payments'][0]['amount'].should == order.total.to_s
+        response.status.should == 200
       end
 
       it "can update payment method with source and transition from payment to confirm" do
@@ -163,27 +163,27 @@ module 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 => source_attributes } }
-        expect(json_response['payments'][0]['payment_method']['name']).to eq(@payment_method.name)
-        expect(json_response['payments'][0]['amount']).to eq(order.total.to_s)
-        expect(response.status).to eq(200)
+        json_response['payments'][0]['payment_method']['name'].should == @payment_method.name
+        json_response['payments'][0]['amount'].should == order.total.to_s
+        response.status.should == 200
       end
 
       it "returns errors when source is missing attributes" do
         order.update_column(:state, "payment")
         api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => {
-            :payments_attributes => [{ :payment_method_id => @payment_method.id.to_s }]
+            :payments_attributes => [{ :payment_method_id => @payment_method.id }]
           },
           :payment_source => {
             @payment_method.id.to_s => { name: "Spree" }
           }
 
-        expect(response.status).to eq(422)
+        response.status.should == 422
         cc_errors = json_response['errors']['payments.Credit Card']
-        expect(cc_errors).to include("Number can't be blank")
-        expect(cc_errors).to include("Month is not a number")
-        expect(cc_errors).to include("Year is not a number")
-        expect(cc_errors).to include("Verification Value can't be blank")
+        cc_errors.should include("Number can't be blank")
+        cc_errors.should include("Month is not a number")
+        cc_errors.should include("Year is not a number")
+        cc_errors.should include("Verification Value can't be blank")
       end
 
       it "allow users to reuse a credit card" do
@@ -199,17 +199,17 @@ module Spree
 
       it "can transition from confirm to complete" do
         order.update_column(:state, "confirm")
-        allow_any_instance_of(Spree::Order).to receive_messages(:payment_required? => false)
+        Spree::Order.any_instance.stub(:payment_required? => false)
         api_put :update, :id => order.to_param, :order_token => order.guest_token
-        expect(json_response['state']).to eq('complete')
-        expect(response.status).to eq(200)
+        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.guest_token
-        expect(json_response['number']).to eq(order.number)
-        expect(response.status).to eq(200)
+        json_response['number'].should == order.number
+        response.status.should == 200
       end
 
       # Regression test for #3784
@@ -227,24 +227,24 @@ module Spree
           # Need to pass email as well so that validations succeed
           api_put :update, :id => order.to_param, :order_token => order.guest_token,
             :order => { :user_id => user.id, :email => "guest@spreecommerce.com" }
-          expect(response.status).to eq(200)
-          expect(json_response['user_id']).to eq(user.id)
+          response.status.should == 200
+          json_response['user_id'].should == user.id
         end
       end
 
       it "can assign an email to the order" do
         api_put :update, :id => order.to_param, :order_token => order.guest_token,
           :order => { :email => "guest@spreecommerce.com" }
-        expect(json_response['email']).to eq("guest@spreecommerce.com")
-        expect(response.status).to eq(200)
+        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"
 
         order.update_column(:state, "payment")
-        expect(PromotionHandler::Coupon).to receive(:new).with(order).and_call_original
-        expect_any_instance_of(PromotionHandler::Coupon).to receive(:apply).and_return({:coupon_applied? => true})
+        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.guest_token, :order => { :coupon_code => "foobar" }
       end
     end
@@ -255,16 +255,16 @@ module Spree
         order.line_items.delete_all
         order.update_column(:email, "spree@example.com")
         api_put :next, :id => order.to_param, :order_token => order.guest_token
-        expect(response.status).to eq(422)
-        expect(json_response["errors"]["base"]).to include(Spree.t(:there_are_no_items_for_this_order))
+        response.status.should == 422
+        json_response["errors"]["base"].should include(Spree.t(:there_are_no_items_for_this_order))
       end
 
       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.guest_token
-        expect(response.status).to eq(200)
-        expect(json_response['state']).to eq('address')
+        response.status.should == 200
+        json_response['state'].should == 'address'
       end
 
       it "cannot transition if order email is blank" do
@@ -274,14 +274,14 @@ module Spree
         )
 
         api_put :next, :id => order.to_param, :order_token => order.guest_token
-        expect(response.status).to eq(422)
-        expect(json_response['error']).to match(/could not be transitioned/)
+        response.status.should == 422
+        json_response['error'].should =~ /could not be transitioned/
       end
 
       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.guest_token, :order => {}
-        expect(json_response["errors"]["base"]).to include(Spree.t(:no_payment_found))
+        json_response["errors"]["base"].should include(Spree.t(:no_payment_found))
       end
     end
 
@@ -289,13 +289,13 @@ module Spree
       let!(:order) { create(:order_with_line_items) }
 
       it 'continues to advance advances an order while it can move forward' do
-        expect_any_instance_of(Spree::Order).to receive(:next).exactly(3).times.and_return(true, true, false)
+        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.guest_token
       end
 
       it 'returns the order' do
         api_put :advance, :id => order.to_param, :order_token => order.guest_token
-        expect(json_response['id']).to eq(order.id)
+        json_response['id'].should == order.id
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ClassificationsController, :type => :controller do
+  describe Api::ClassificationsController do
     let(:taxon) do
       taxon = create(:taxon)
       3.times do
@@ -18,7 +18,7 @@ module Spree
     context "as a user" do
       it "cannot change the order of a product" do
         api_put :update, :taxon_id => taxon, :product_id => taxon.products.first, :position => 1
-        expect(response.status).to eq(401)
+        response.status.should == 401
       end
     end
 
@@ -28,10 +28,10 @@ module Spree
       it "can change the order a product" do
         last_product = taxon.products.last
         classification = taxon.classifications.find_by(:product_id => last_product.id)
-        expect(classification.position).to eq(3)
+        classification.position.should == 3
         api_put :update, :taxon_id => taxon, :product_id => last_product, :position => 0
-        expect(response.status).to eq(200)
-        expect(classification.reload.position).to eq(1)
+        response.status.should == 200
+        classification.reload.position.should == 1
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ConfigController, :type => :controller do
+  describe Api::ConfigController do
     render_views
 
     before do
@@ -10,18 +10,18 @@ module Spree
 
     it "returns Spree::Money settings" do
       api_get :money
-      expect(response).to be_success
-      expect(json_response["symbol"]).to eq("$")
-      expect(json_response["symbol_position"]).to eq("before")
-      expect(json_response["no_cents"]).to eq(false)
-      expect(json_response["decimal_mark"]).to eq(".")
-      expect(json_response["thousands_separator"]).to eq(",")
+      response.should be_success
+      json_response["symbol"].should == "$"
+      json_response["symbol_position"].should == "before"
+      json_response["no_cents"].should == false
+      json_response["decimal_mark"].should == "."
+      json_response["thousands_separator"].should == ","
     end
 
     it "returns some configuration settings" do
       api_get :show
-      expect(response).to be_success
-      expect(json_response["default_country_id"]).to eq(Spree::Config[:default_country_id])
+      response.should be_success
+      json_response["default_country_id"].should == Spree::Config[:default_country_id]
     end
   end
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::CountriesController, :type => :controller do
+  describe Api::CountriesController do
     render_views
 
     before do
@@ -12,7 +12,7 @@ module Spree
 
     it "gets all countries" do
       api_get :index
-      expect(json_response['countries'].first['iso3']).to eq @country.iso3
+      json_response['countries'].first['iso3'].should eq @country.iso3
     end
 
     context "with two countries" do
@@ -20,29 +20,29 @@ module Spree
 
       it "can view all countries" do
         api_get :index
-        expect(json_response['count']).to eq(2)
-        expect(json_response['current_page']).to eq(1)
-        expect(json_response['pages']).to eq(1)
+        json_response['count'].should == 2
+        json_response['current_page'].should == 1
+        json_response['pages'].should == 1
       end
 
       it 'can query the results through a paramter' do
         api_get :index, :q => { :name_cont => 'zam' }
-        expect(json_response['count']).to eq(1)
-        expect(json_response['countries'].first['name']).to eq @zambia.name
+        json_response['count'].should == 1
+        json_response['countries'].first['name'].should eq @zambia.name
       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
     end
 
     it "includes states" do
       api_get :show, :id => @country.id
       states = json_response['states']
-      expect(states.first['name']).to eq @state.name
+      states.first['name'].should eq @state.name
     end
   end
 end

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

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::CreditCardsController, :type => :controller do
+  describe Api::CreditCardsController do
     render_views
 
     let!(:admin_user) do
       user = Spree.user_class.new(:email => "spree@example.com", :id => 1)
       user.generate_spree_api_key!
-      allow(user).to receive(:has_spree_role?).with('admin').and_return(true)
+      user.stub(:has_spree_role?).with('admin').and_return(true)
       user
     end
 
@@ -25,7 +25,7 @@ module Spree
 
     it "the user id doesn't exist" do
       api_get :index, user_id: 1000
-      expect(response.status).to eq(404)
+      response.status.should == 404
     end
 
     context "calling user is in admin role" do
@@ -37,18 +37,18 @@ module Spree
       it "no credit cards exist for user" do
         api_get :index, user_id: normal_user.id
 
-        expect(response.status).to eq(200)
-        expect(json_response["pages"]).to eq(0)
+        response.status.should == 200
+        json_response["pages"].should == 0
       end
 
       it "can view all credit cards for user" do
         api_get :index, user_id: current_api_user.id
 
-        expect(response.status).to eq(200)
-        expect(json_response["pages"]).to eq(1)
-        expect(json_response["current_page"]).to eq(1)
-        expect(json_response["credit_cards"].length).to eq(1)
-        expect(json_response["credit_cards"].first["id"]).to eq(card.id)
+        response.status.should == 200
+        json_response["pages"].should == 1
+        json_response["current_page"].should == 1
+        json_response["credit_cards"].length.should == 1
+        json_response["credit_cards"].first["id"].should == card.id
       end
     end
 
@@ -63,17 +63,17 @@ module Spree
       it "can not view user" do
         api_get :index, user_id: admin_user.id
 
-        expect(response.status).to eq(404)
+        response.status.should == 404
       end
 
       it "can view own credit cards" do
         api_get :index, user_id: normal_user.id
 
-        expect(response.status).to eq(200)
-        expect(json_response["pages"]).to eq(1)
-        expect(json_response["current_page"]).to eq(1)
-        expect(json_response["credit_cards"].length).to eq(1)
-        expect(json_response["credit_cards"].first["id"]).to eq(card.id)
+        response.status.should == 200
+        json_response["pages"].should == 1
+        json_response["current_page"].should == 1
+        json_response["credit_cards"].length.should == 1
+        json_response["credit_cards"].first["id"].should == card.id
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::ImagesController, :type => :controller do
+  describe Spree::Api::ImagesController do
     render_views
 
     let!(:product) { create(:product) }
@@ -17,32 +17,58 @@ module Spree
       sign_in_as_admin!
 
       it "can upload a new image for a variant" do
-        expect do
+        lambda do
           api_post :create,
                    :image => { :attachment => upload_image('thinking-cat.jpg'),
                                :viewable_type => 'Spree::Variant',
                                :viewable_id => product.master.to_param  },
                    :product_id => product.id
-          expect(response.status).to eq(201)
-          expect(json_response).to have_attributes(attributes)
-        end.to change(Image, :count).by(1)
+          response.status.should == 201
+          json_response.should have_attributes(attributes)
+        end.should change(Image, :count).by(1)
       end
 
       context "working with an existing image" do
         let!(:product_image) { product.master.images.create!(:attachment => image('thinking-cat.jpg')) }
 
+        it "can get a single product image" do
+          api_get :show, :id => product_image.id, :product_id => product.id
+          response.status.should == 200
+          json_response.should have_attributes(attributes)
+        end
+
+        it "can get a single variant image" do
+          api_get :show, :id => product_image.id, :variant_id => product.master.id
+          response.status.should == 200
+          json_response.should have_attributes(attributes)
+        end
+
+        it "can get a list of product images" do
+          api_get :index, :product_id => product.id
+          response.status.should == 200
+          json_response.should have_key("images")
+          json_response["images"].first.should have_attributes(attributes)
+        end
+
+        it "can get a list of variant images" do
+          api_get :index, :variant_id => product.master.id
+          response.status.should == 200
+          json_response.should have_key("images")
+          json_response["images"].first.should have_attributes(attributes)
+        end
+
         it "can update image data" do
-          expect(product_image.position).to eq(1)
+          product_image.position.should == 1
           api_post :update, :image => { :position => 2 }, :id => product_image.id, :product_id => product.id
-          expect(response.status).to eq(200)
-          expect(json_response).to have_attributes(attributes)
-          expect(product_image.reload.position).to eq(2)
+          response.status.should == 200
+          json_response.should have_attributes(attributes)
+          product_image.reload.position.should == 2
         end
 
         it "can delete an image" do
           api_delete :destroy, :id => product_image.id, :product_id => product.id
-          expect(response.status).to eq(204)
-          expect { product_image.reload }.to raise_error(ActiveRecord::RecordNotFound)
+          response.status.should == 204
+          lambda { product_image.reload }.should raise_error(ActiveRecord::RecordNotFound)
         end
       end
     end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::InventoryUnitsController, :type => :controller do
+  describe Api::InventoryUnitsController do
     render_views
 
     before do
@@ -14,13 +14,13 @@ module Spree
 
       it "gets an inventory unit" do
         api_get :show, :id => @inventory_unit.id
-        expect(json_response['state']).to eq @inventory_unit.state
+        json_response['state'].should eq @inventory_unit.state
       end
 
       it "updates an inventory unit (only shipment is accessable by default)" do
         api_put :update, :id => @inventory_unit.id,
                          :inventory_unit => { :shipment => nil }
-        expect(json_response['shipment_id']).to be_nil
+        json_response['shipment_id'].should be_nil
       end
 
       context 'fires state event' do
@@ -29,19 +29,19 @@ module Spree
                            :fire => 'ship',
                            :inventory_unit => { :shipment => nil }
 
-          expect(json_response['state']).to eq 'shipped'
+          json_response['state'].should eq 'shipped'
         end
 
         it 'and returns exception if cannot fire' do
           api_put :update, :id => @inventory_unit.id,
                            :fire => 'return'
-          expect(json_response['exception']).to match /cannot transition to return/
+          json_response['exception'].should match /cannot transition to return/
         end
 
         it 'and returns exception bad state' do
           api_put :update, :id => @inventory_unit.id,
                            :fire => 'bad'
-          expect(json_response['exception']).to match /cannot transition to bad/
+          json_response['exception'].should match /cannot transition to bad/
         end
       end
     end