spree_api 2.3.13 → 2.4.0.rc1

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

@@ -1,89 +1,87 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::LineItemsController, :type => :controller do
+  describe Api::LineItemsController do
     render_views
 
-    let!(:order) { create(:order_with_line_items) }
+    let!(:order) { create(:order_with_line_items, line_items_count: 1) }
 
     let(:product) { create(:product) }
     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
-      expect(json_response["attributes"]).to eq(["quantity", "price", "variant_id"])
+      json_response["attributes"].should == ["quantity", "price", "variant_id"]
       required_attributes = json_response["required_attributes"]
-      expect(required_attributes).to include("quantity", "variant_id")
+      required_attributes.should 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
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["variant"]["name"]).not_to be_blank
+        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.guest_token
         api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["variant"]["name"]).not_to be_blank
+        response.status.should == 201
+        json_response.should have_attributes(attributes)
+        json_response["variant"]["name"].should_not be_blank
       end
     end
 
     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
         api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["variant"]["name"]).not_to be_blank
+        response.status.should == 201
+        json_response.should have_attributes(attributes)
+        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 }
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
+        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 }
-        expect(response.status).to eq(201)
+        response.status.should == 201
         order.reload
-        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)
+        order.line_items.count.should == 2 # 1 original due to factory, + 1 in this test
+        json_response.should have_attributes(attributes)
+        json_response["quantity"].should == 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 }
-        expect(response.status).to eq(200)
+        response.status.should == 200
         order.reload
-        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)
+        order.total.should == 1010 # 10 original due to factory, + 1000 in this test
+        json_response.should have_attributes(attributes)
+        json_response["quantity"].should == 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
-        expect(response.status).to eq(204)
+        response.status.should == 204
         order.reload
-        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)
+        order.line_items.count.should == 0 # 1 original due to factory, - 1 in this test
+        lambda { line_item.reload }.should raise_error(ActiveRecord::RecordNotFound)
       end
 
       context "order contents changed after shipments were created" do
@@ -112,8 +110,8 @@ module Spree
 
         context "order is completed" do
           before do
-            allow(order).to receive_messages completed?: true
-            allow(Order).to receive_message_chain :includes, find_by!: order
+            order.stub completed?: true
+            Order.stub_chain :includes, find_by!: order
           end
 
           it "doesn't destroy shipments or restart checkout flow" do
@@ -128,6 +126,7 @@ module Spree
     context "as just another user" do
       before do
         user = create(:user)
+        controller.stub :try_spree_current_user => user
       end
 
       it "cannot add a new line item to the order" do
@@ -139,14 +138,14 @@ module Spree
         line_item = order.line_items.first
         api_put :update, :id => line_item.id, :line_item => { :quantity => 1000 }
         assert_unauthorized!
-        expect(line_item.reload.quantity).not_to eq(1000)
+        line_item.reload.quantity.should_not == 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!
-        expect { line_item.reload }.not_to raise_error
+        lambda { line_item.reload }.should_not 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, :type => :controller do
+  describe Api::OptionTypesController do
     render_views
 
     let(:attributes) { [:id, :name, :position, :presentation] }
@@ -13,15 +13,15 @@ module Spree
     end
 
     def check_option_values(option_values)
-      expect(option_values.count).to eq(1)
-      expect(option_values.first).to have_attributes([:id, :name, :presentation,
+      option_values.count.should == 1
+      option_values.first.should have_attributes([:id, :name, :presentation,
                                                   :option_type_name, :option_type_id])
     end
 
     it "can list all option types" do
       api_get :index
-      expect(json_response.count).to eq(1)
-      expect(json_response.first).to have_attributes(attributes)
+      json_response.count.should == 1
+      json_response.first.should 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 }
-      expect(json_response.count).to eq(1)
-      expect(json_response.first).to have_attributes(attributes)
+      json_response.count.should == 1
+      json_response.first.should 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}"
-      expect(json_response.count).to eq(2)
+      json_response.count.should == 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
-      expect(json_response).to have_attributes(attributes)
+      json_response.should have_attributes(attributes)
       check_option_values(json_response["option_values"])
     end
 
@@ -63,13 +63,13 @@ module Spree
                           :name => "Option Type"
                         }
       assert_not_found!
-      expect(option_type.reload.name).to eq(original_name)
+      option_type.reload.name.should == original_name
     end
 
     it "cannot delete an option type" do
       api_delete :destroy, :id => option_type.id
       assert_not_found!
-      expect { option_type.reload }.not_to raise_error
+      lambda { option_type.reload }.should_not raise_error
     end
 
     context "as an admin" do
@@ -80,13 +80,13 @@ module Spree
                           :name => "Option Type",
                           :presentation => "Option Type"
                         }
-        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 "cannot create an option type with invalid attributes" do
         api_post :create, :option_type => {}
-        expect(response.status).to eq(422)
+        response.status.should == 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",
                             }
-        expect(response.status).to eq(200)
+        response.status.should == 200
 
         option_type.reload
-        expect(option_type.name).to eq("Option Type")
+        option_type.name.should == "Option Type"
       end
 
       it "cannot update an option type with invalid attributes" do
         api_put :update, :id => option_type.id, :option_type => {
                           :name => ""
                          }
-        expect(response.status).to eq(422)
+        response.status.should == 422
       end
 
       it "can delete an option type" do
         api_delete :destroy, :id => option_type.id
-        expect(response.status).to eq(204)
+        response.status.should == 204
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::OptionValuesController, :type => :controller do
+  describe Api::OptionValuesController do
     render_views
 
     let(:attributes) { [:id, :name, :presentation, :option_type_name, :option_type_name] }
@@ -13,8 +13,8 @@ module Spree
     end
 
     def check_option_values(option_values)
-      expect(option_values.count).to eq(1)
-      expect(option_values.first).to have_attributes([:id, :name, :presentation,
+      option_values.count.should == 1
+      option_values.first.should have_attributes([:id, :name, :presentation,
                                                   :option_type_name, :option_type_id])
     end
 
@@ -26,8 +26,8 @@ module Spree
 
       it "can retreive a list of all option values" do
         api_get :index
-        expect(json_response.count).to eq(2)
-        expect(json_response.first).to have_attributes(attributes)
+        json_response.count.should == 2
+        json_response.first.should have_attributes(attributes)
       end
     end
 
@@ -36,27 +36,27 @@ module Spree
 
       it "can list all option values" do
         api_get :index
-        expect(json_response.count).to eq(1)
-        expect(json_response.first).to have_attributes(attributes)
+        json_response.count.should == 1
+        json_response.first.should have_attributes(attributes)
       end
 
       it "can search for an option type" do
         create(:option_value, :name => "buzz")
         api_get :index, :q => { :name_cont => option_value.name }
-        expect(json_response.count).to eq(1)
-        expect(json_response.first).to have_attributes(attributes)
+        json_response.count.should == 1
+        json_response.first.should have_attributes(attributes)
       end
 
       it "can retreive a list of option types" do
         option_value_1 = create(:option_value, :option_type => option_type)
         option_value_2 = create(:option_value, :option_type => option_type)
         api_get :index, :ids => [option_value.id, option_value_1.id]
-        expect(json_response.count).to eq(2)
+        json_response.count.should == 2
       end
 
       it "can list a single option value" do
         api_get :show, :id => option_value.id
-        expect(json_response).to have_attributes(attributes)
+        json_response.should have_attributes(attributes)
       end
 
       it "cannot create a new option value" do
@@ -74,13 +74,13 @@ module Spree
                             :name => "Option Value"
                           }
         assert_not_found!
-        expect(option_type.reload.name).to eq(original_name)
+        option_type.reload.name.should == original_name
       end
 
       it "cannot delete an option value" do
         api_delete :destroy, :id => option_type.id
         assert_not_found!
-        expect { option_type.reload }.not_to raise_error
+        lambda { option_type.reload }.should_not raise_error
       end
 
       context "as an admin" do
@@ -91,13 +91,13 @@ module Spree
                             :name => "Option Value",
                             :presentation => "Option Value"
                           }
-          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 "cannot create an option type with invalid attributes" do
           api_post :create, :option_value => {}
-          expect(response.status).to eq(422)
+          response.status.should == 422
         end
 
         it "can update an option value" do
@@ -105,14 +105,14 @@ module Spree
           api_put :update, :id => option_value.id, :option_value => {
                                 :name => "Option Value",
                               }
-          expect(response.status).to eq(200)
+          response.status.should == 200
 
           option_value.reload
-          expect(option_value.name).to eq("Option Value")
+          option_value.name.should == "Option Value"
         end
 
         it "permits the correct attributes" do
-          expect(controller).to receive(:permitted_option_value_attributes)
+          controller.should_receive(:permitted_option_value_attributes)
           api_put :update, :id => option_value.id, :option_value => {
                             :name => ""
                            }
@@ -122,12 +122,12 @@ module Spree
           api_put :update, :id => option_value.id, :option_value => {
                             :name => ""
                            }
-          expect(response.status).to eq(422)
+          response.status.should == 422
         end
 
         it "can delete an option value" do
           api_delete :destroy, :id => option_value.id
-          expect(response.status).to eq(204)
+          response.status.should == 204
         end
       end
     end