spree_api 2.3.4 → 2.3.5

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ClassificationsController do
+  describe Api::ClassificationsController, :type => :controller 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
-        response.status.should == 401
+        expect(response.status).to eq(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)
-        classification.position.should == 3
+        expect(classification.position).to eq(3)
         api_put :update, :taxon_id => taxon, :product_id => last_product, :position => 0
-        response.status.should == 200
-        classification.reload.position.should == 1
+        expect(response.status).to eq(200)
+        expect(classification.reload.position).to eq(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 do
+  describe Api::ConfigController, :type => :controller do
     render_views
 
     before do
@@ -10,18 +10,18 @@ module Spree
 
     it "returns Spree::Money settings" do
       api_get :money
-      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 == ","
+      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(",")
     end
 
     it "returns some configuration settings" do
       api_get :show
-      response.should be_success
-      json_response["default_country_id"].should == Spree::Config[:default_country_id]
+      expect(response).to be_success
+      expect(json_response["default_country_id"]).to eq(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 do
+  describe Api::CountriesController, :type => :controller do
     render_views
 
     before do
@@ -12,7 +12,7 @@ module Spree
 
     it "gets all countries" do
       api_get :index
-      json_response['countries'].first['iso3'].should eq @country.iso3
+      expect(json_response['countries'].first['iso3']).to eq @country.iso3
     end
 
     context "with two countries" do
@@ -20,29 +20,29 @@ module Spree
 
       it "can view all countries" do
         api_get :index
-        json_response['count'].should == 2
-        json_response['current_page'].should == 1
-        json_response['pages'].should == 1
+        expect(json_response['count']).to eq(2)
+        expect(json_response['current_page']).to eq(1)
+        expect(json_response['pages']).to eq(1)
       end
 
       it 'can query the results through a paramter' do
         api_get :index, :q => { :name_cont => 'zam' }
-        json_response['count'].should == 1
-        json_response['countries'].first['name'].should eq @zambia.name
+        expect(json_response['count']).to eq(1)
+        expect(json_response['countries'].first['name']).to eq @zambia.name
       end
 
       it 'can control the page size through a parameter' do
         api_get :index, :per_page => 1
-        json_response['count'].should == 1
-        json_response['current_page'].should == 1
-        json_response['pages'].should == 2
+        expect(json_response['count']).to eq(1)
+        expect(json_response['current_page']).to eq(1)
+        expect(json_response['pages']).to eq(2)
       end
     end
 
     it "includes states" do
       api_get :show, :id => @country.id
       states = json_response['states']
-      states.first['name'].should eq @state.name
+      expect(states.first['name']).to 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 do
+  describe Api::CreditCardsController, :type => :controller do
     render_views
 
     let!(:admin_user) do
       user = Spree.user_class.new(:email => "spree@example.com", :id => 1)
       user.generate_spree_api_key!
-      user.stub(:has_spree_role?).with('admin').and_return(true)
+      allow(user).to receive(: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
-      response.status.should == 404
+      expect(response.status).to eq(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
 
-        response.status.should == 200
-        json_response["pages"].should == 0
+        expect(response.status).to eq(200)
+        expect(json_response["pages"]).to eq(0)
       end
 
       it "can view all credit cards for user" do
         api_get :index, user_id: current_api_user.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
+        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)
       end
     end
 
@@ -63,17 +63,17 @@ module Spree
       it "can not view user" do
         api_get :index, user_id: admin_user.id
 
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it "can view own credit cards" do
         api_get :index, user_id: normal_user.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
+        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)
       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 do
+  describe Spree::Api::ImagesController, :type => :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -17,32 +17,32 @@ module Spree
       sign_in_as_admin!
 
       it "can upload a new image for a variant" do
-        lambda do
+        expect 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
-          response.status.should == 201
-          json_response.should have_attributes(attributes)
-        end.should change(Image, :count).by(1)
+          expect(response.status).to eq(201)
+          expect(json_response).to have_attributes(attributes)
+        end.to 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 update image data" do
-          product_image.position.should == 1
+          expect(product_image.position).to eq(1)
           api_post :update, :image => { :position => 2 }, :id => product_image.id, :product_id => product.id
-          response.status.should == 200
-          json_response.should have_attributes(attributes)
-          product_image.reload.position.should == 2
+          expect(response.status).to eq(200)
+          expect(json_response).to have_attributes(attributes)
+          expect(product_image.reload.position).to eq(2)
         end
 
         it "can delete an image" do
           api_delete :destroy, :id => product_image.id, :product_id => product.id
-          response.status.should == 204
-          lambda { product_image.reload }.should raise_error(ActiveRecord::RecordNotFound)
+          expect(response.status).to eq(204)
+          expect { product_image.reload }.to 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 do
+  describe Api::InventoryUnitsController, :type => :controller do
     render_views
 
     before do
@@ -14,13 +14,13 @@ module Spree
 
       it "gets an inventory unit" do
         api_get :show, :id => @inventory_unit.id
-        json_response['state'].should eq @inventory_unit.state
+        expect(json_response['state']).to 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 }
-        json_response['shipment_id'].should be_nil
+        expect(json_response['shipment_id']).to be_nil
       end
 
       context 'fires state event' do
@@ -29,19 +29,19 @@ module Spree
                            :fire => 'ship',
                            :inventory_unit => { :shipment => nil }
 
-          json_response['state'].should eq 'shipped'
+          expect(json_response['state']).to eq 'shipped'
         end
 
         it 'and returns exception if cannot fire' do
           api_put :update, :id => @inventory_unit.id,
                            :fire => 'return'
-          json_response['exception'].should match /cannot transition to return/
+          expect(json_response['exception']).to match /cannot transition to return/
         end
 
         it 'and returns exception bad state' do
           api_put :update, :id => @inventory_unit.id,
                            :fire => 'bad'
-          json_response['exception'].should match /cannot transition to bad/
+          expect(json_response['exception']).to match /cannot transition to bad/
         end
       end
     end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::LineItemsController do
+  describe Api::LineItemsController, :type => :controller do
     render_views
 
     let!(:order) { create(:order_with_line_items) }
@@ -11,77 +11,77 @@ module Spree
     let(:resource_scoping) { { :order_id => order.to_param } }
 
     it "can learn how to create a new line item" do
-      controller.stub :try_spree_current_user => current_api_user
+      allow(controller).to receive_messages :try_spree_current_user => current_api_user
       api_get :new
-      json_response["attributes"].should == ["quantity", "price", "variant_id"]
+      expect(json_response["attributes"]).to eq(["quantity", "price", "variant_id"])
       required_attributes = json_response["required_attributes"]
-      required_attributes.should include("quantity", "variant_id")
+      expect(required_attributes).to include("quantity", "variant_id")
     end
 
     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.guest_token
-        response.status.should == 201
-        json_response.should have_attributes(attributes)
-        json_response["variant"]["name"].should_not be_blank
+        expect(response.status).to eq(201)
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response["variant"]["name"]).not_to 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.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)
-        json_response["variant"]["name"].should_not be_blank
+        expect(response.status).to eq(201)
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response["variant"]["name"]).not_to be_blank
       end
     end
 
     context "as the order owner" do
       before do
-        controller.stub :try_spree_current_user => current_api_user
-        Order.any_instance.stub :user => current_api_user
+        allow(controller).to receive_messages :try_spree_current_user => current_api_user
+        allow_any_instance_of(Order).to receive_messages :user => current_api_user
       end
 
       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 }
-        response.status.should == 201
-        json_response.should have_attributes(attributes)
-        json_response["variant"]["name"].should_not be_blank
+        expect(response.status).to eq(201)
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response["variant"]["name"]).not_to 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(response.status).to eq(201)
+        expect(json_response).to 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 }
-        response.status.should == 201
+        expect(response.status).to eq(201)
         order.reload
-        order.line_items.count.should == 6 # 5 original due to factory, + 1 in this test
-        json_response.should have_attributes(attributes)
-        json_response["quantity"].should == 11
+        expect(order.line_items.count).to eq(6) # 5 original due to factory, + 1 in this test
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response["quantity"]).to eq(11)
       end
 
       it "can update a line item on the order" do
         line_item = order.line_items.first
         api_put :update, :id => line_item.id, :line_item => { :quantity => 101 }
-        response.status.should == 200
+        expect(response.status).to eq(200)
         order.reload
-        order.total.should == 1050 # 50 original due to factory, + 1000 in this test
-        json_response.should have_attributes(attributes)
-        json_response["quantity"].should == 101
+        expect(order.total).to eq(1050) # 50 original due to factory, + 1000 in this test
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response["quantity"]).to eq(101)
       end
 
       it "can delete a line item on the order" do
         line_item = order.line_items.first
         api_delete :destroy, :id => line_item.id
-        response.status.should == 204
+        expect(response.status).to eq(204)
         order.reload
-        order.line_items.count.should == 4 # 5 original due to factory, - 1 in this test
-        lambda { line_item.reload }.should raise_error(ActiveRecord::RecordNotFound)
+        expect(order.line_items.count).to eq(4) # 5 original due to factory, - 1 in this test
+        expect { line_item.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end
 
       context "order contents changed after shipments were created" do
@@ -110,8 +110,8 @@ module Spree
 
         context "order is completed" do
           before do
-            order.stub completed?: true
-            Order.stub_chain :includes, find_by!: order
+            allow(order).to receive_messages completed?: true
+            allow(Order).to receive_message_chain :includes, find_by!: order
           end
 
           it "doesn't destroy shipments or restart checkout flow" do
@@ -126,7 +126,7 @@ module Spree
     context "as just another user" do
       before do
         user = create(:user)
-        controller.stub :try_spree_current_user => user
+        allow(controller).to receive_messages :try_spree_current_user => user
       end
 
       it "cannot add a new line item to the order" do
@@ -138,14 +138,14 @@ module Spree
         line_item = order.line_items.first
         api_put :update, :id => line_item.id, :line_item => { :quantity => 1000 }
         assert_unauthorized!
-        line_item.reload.quantity.should_not == 1000
+        expect(line_item.reload.quantity).not_to eq(1000)
       end
 
       it "cannot delete a line item on the order" do
         line_item = order.line_items.first
         api_delete :destroy, :id => line_item.id
         assert_unauthorized!
-        lambda { line_item.reload }.should_not raise_error
+        expect { line_item.reload }.not_to raise_error
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::OptionTypesController do
+  describe Api::OptionTypesController, :type => :controller do
     render_views
 
     let(:attributes) { [:id, :name, :position, :presentation] }
@@ -13,15 +13,15 @@ module Spree
     end
 
     def check_option_values(option_values)
-      option_values.count.should == 1
-      option_values.first.should have_attributes([:id, :name, :presentation,
+      expect(option_values.count).to eq(1)
+      expect(option_values.first).to have_attributes([:id, :name, :presentation,
                                                   :option_type_name, :option_type_id])
     end
 
     it "can list all option types" do
       api_get :index
-      json_response.count.should == 1
-      json_response.first.should have_attributes(attributes)
+      expect(json_response.count).to eq(1)
+      expect(json_response.first).to have_attributes(attributes)
 
       check_option_values(json_response.first["option_values"])
     end
@@ -29,22 +29,22 @@ module Spree
     it "can search for an option type" do
       create(:option_type, :name => "buzz")
       api_get :index, :q => { :name_cont => option_type.name }
-      json_response.count.should == 1
-      json_response.first.should have_attributes(attributes)
+      expect(json_response.count).to eq(1)
+      expect(json_response.first).to have_attributes(attributes)
     end
 
     it "can retreive a list of specific option types" do
       option_type_1 = create(:option_type)
       option_type_2 = create(:option_type)
       api_get :index, :ids => "#{option_type.id},#{option_type_1.id}"
-      json_response.count.should == 2
+      expect(json_response.count).to eq(2)
 
       check_option_values(json_response.first["option_values"])
     end
 
     it "can list a single option type" do
       api_get :show, :id => option_type.id
-      json_response.should have_attributes(attributes)
+      expect(json_response).to have_attributes(attributes)
       check_option_values(json_response["option_values"])
     end
 
@@ -63,13 +63,13 @@ module Spree
                           :name => "Option Type"
                         }
       assert_not_found!
-      option_type.reload.name.should == original_name
+      expect(option_type.reload.name).to eq(original_name)
     end
 
     it "cannot delete an option type" do
       api_delete :destroy, :id => option_type.id
       assert_not_found!
-      lambda { option_type.reload }.should_not raise_error
+      expect { option_type.reload }.not_to raise_error
     end
 
     context "as an admin" do
@@ -80,13 +80,13 @@ module Spree
                           :name => "Option Type",
                           :presentation => "Option Type"
                         }
-        json_response.should have_attributes(attributes)
-        response.status.should == 201
+        expect(json_response).to have_attributes(attributes)
+        expect(response.status).to eq(201)
       end
 
       it "cannot create an option type with invalid attributes" do
         api_post :create, :option_type => {}
-        response.status.should == 422
+        expect(response.status).to eq(422)
       end
 
       it "can update an option type" do
@@ -94,22 +94,22 @@ module Spree
         api_put :update, :id => option_type.id, :option_type => {
                               :name => "Option Type",
                             }
-        response.status.should == 200
+        expect(response.status).to eq(200)
 
         option_type.reload
-        option_type.name.should == "Option Type"
+        expect(option_type.name).to eq("Option Type")
       end
 
       it "cannot update an option type with invalid attributes" do
         api_put :update, :id => option_type.id, :option_type => {
                           :name => ""
                          }
-        response.status.should == 422
+        expect(response.status).to eq(422)
       end
 
       it "can delete an option type" do
         api_delete :destroy, :id => option_type.id
-        response.status.should == 204
+        expect(response.status).to eq(204)
       end
     end
   end