solidus_api 1.2.3 → 1.3.0.beta1

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::CreditCardsController, :type => :controller do
+  describe Api::CreditCardsController, type: :controller do
     describe '#index' do
       render_views
 
@@ -13,7 +13,7 @@ module Spree
         create(:user, :with_api_key)
       end
 
-      let!(:card) { create(:credit_card, :user_id => admin_user.id, gateway_customer_profile_id: "random") }
+      let!(:card) { create(:credit_card, user_id: admin_user.id, gateway_customer_profile_id: "random") }
 
       before do
         stub_authentication!
@@ -52,7 +52,7 @@ module Spree
           normal_user
         end
 
-        let!(:card) { create(:credit_card, :user_id => normal_user.id, gateway_customer_profile_id: "random") }
+        let!(:card) { create(:credit_card, user_id: normal_user.id, gateway_customer_profile_id: "random") }
 
         it "can not view user" do
           api_get :index, user_id: admin_user.id
@@ -85,7 +85,7 @@ module Spree
 
         it 'updates the credit card' do
           expect {
-            api_put :update, id: credit_card.to_param, credit_card: {name: 'Jordan Brough'}
+            api_put :update, id: credit_card.to_param, credit_card: { name: 'Jordan Brough' }
           }.to change {
             credit_card.reload.name
           }.from('Joe Shmoe').to('Jordan Brough')
@@ -96,7 +96,7 @@ module Spree
         let(:current_api_user) { create(:user) }
 
         it 'rejects the request' do
-          api_put :update, id: credit_card.to_param, credit_card: {name: 'Jordan Brough'}
+          api_put :update, id: credit_card.to_param, credit_card: { name: 'Jordan Brough' }
           expect(response.status).to eq(401)
         end
       end

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

@@ -1,13 +1,15 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::ImagesController, :type => :controller do
+  describe Spree::Api::ImagesController, type: :controller do
     render_views
 
     let!(:product) { create(:product) }
-    let!(:attributes) { [:id, :position, :attachment_content_type,
-                         :attachment_file_name, :type, :attachment_updated_at, :attachment_width,
-                         :attachment_height, :alt] }
+    let!(:attributes) {
+      [:id, :position, :attachment_content_type,
+       :attachment_file_name, :type, :attachment_updated_at, :attachment_width,
+       :attachment_height, :alt]
+    }
 
     before do
       stub_authentication!
@@ -19,39 +21,39 @@ module Spree
       it "can upload a new image for a variant" 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
+                   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)
       end
 
       context "working with an existing image" do
-        let!(:product_image) { product.master.images.create!(:attachment => image('thinking-cat.jpg')) }
+        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
+          api_get :show, id: product_image.id, product_id: product.id
           expect(response.status).to eq(200)
           expect(json_response).to have_attributes(attributes)
         end
 
         it "can get a single variant image" do
-          api_get :show, :id => product_image.id, :variant_id => product.master.id
+          api_get :show, id: product_image.id, variant_id: product.master.id
           expect(response.status).to eq(200)
           expect(json_response).to have_attributes(attributes)
         end
 
         it "can get a list of product images" do
-          api_get :index, :product_id => product.id
+          api_get :index, product_id: product.id
           expect(response.status).to eq(200)
           expect(json_response).to have_key("images")
           expect(json_response["images"].first).to have_attributes(attributes)
         end
 
         it "can get a list of variant images" do
-          api_get :index, :variant_id => product.master.id
+          api_get :index, variant_id: product.master.id
           expect(response.status).to eq(200)
           expect(json_response).to have_key("images")
           expect(json_response["images"].first).to have_attributes(attributes)
@@ -59,14 +61,14 @@ module Spree
 
         it "can update image data" do
           expect(product_image.position).to eq(1)
-          api_post :update, :image => { :position => 2 }, :id => product_image.id, :product_id => product.id
+          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)
         end
 
         it "can delete an image" do
-          api_delete :destroy, :id => product_image.id, :product_id => product.id
+          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)
         end
@@ -75,17 +77,17 @@ module Spree
 
     context "as a non-admin" do
       it "cannot create an image" do
-        api_post :create, :product_id => product.id
+        api_post :create, product_id: product.id
         assert_unauthorized!
       end
 
       it "cannot update an image" do
-        api_put :update, :id => 1, :product_id => product.id
+        api_put :update, id: 1, product_id: product.id
         assert_not_found!
       end
 
       it "cannot delete an image" do
-        api_delete :destroy, :id => 1, :product_id => product.id
+        api_delete :destroy, id: 1, product_id: product.id
         assert_not_found!
       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, type: :controller do
     render_views
 
     before do
@@ -14,34 +14,34 @@ module Spree
       let(:variant) { create(:variant) }
 
       it "gets an inventory unit" do
-        api_get :show, :id => @inventory_unit.id
+        api_get :show, id: @inventory_unit.id
         expect(json_response['state']).to eq @inventory_unit.state
       end
 
       it "updates an inventory unit" do
-        api_put :update, :id => @inventory_unit.id,
-                         :inventory_unit => { variant_id: variant.id }
+        api_put :update, id: @inventory_unit.id,
+                         inventory_unit: { variant_id: variant.id }
         expect(json_response['variant_id']).to eq variant.id
       end
 
       context 'fires state event' do
         it 'if supplied with :fire param' do
-          api_put :update, :id => @inventory_unit.id,
-                           :fire => 'ship',
-                           :inventory_unit => { variant_id: variant.id }
+          api_put :update, id: @inventory_unit.id,
+                           fire: 'ship',
+                           inventory_unit: { variant_id: variant.id }
 
           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'
+          api_put :update, id: @inventory_unit.id,
+                           fire: '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'
+          api_put :update, id: @inventory_unit.id,
+                           fire: 'bad'
           expect(json_response['exception']).to match /cannot transition to bad/
         end
       end

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

@@ -12,14 +12,14 @@ module Spree
   # This should go in an initializer
   Spree::Api::LineItemsController.line_item_options += [:some_option]
 
-  describe Api::LineItemsController, :type => :controller do
+  describe Api::LineItemsController, type: :controller do
     render_views
 
     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 } }
+    let(:resource_scoping) { { order_id: order.to_param } }
 
     before do
       stub_authentication!
@@ -34,7 +34,7 @@ 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.guest_token
+        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
@@ -42,7 +42,7 @@ module Spree
 
       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 }
+        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
@@ -51,11 +51,11 @@ module Spree
 
     context "as the order owner" do
       before do
-        allow_any_instance_of(Order).to receive_messages :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 }
+        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
@@ -73,15 +73,15 @@ module Spree
       end
 
       it "default quantity to 1 if none is given" do
-        api_post :create, :line_item => { :variant_id => product.master.to_param }
+        api_post :create, line_item: { variant_id: product.master.to_param }
         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 }
+        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)
         order.reload
         expect(order.line_items.count).to eq(2) # 1 original due to factory, + 1 in this test
@@ -91,7 +91,7 @@ module Spree
 
       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 }
+        api_put :update, id: line_item.id, line_item: { quantity: 101 }
         expect(response.status).to eq(200)
         order.reload
         expect(order.total).to eq(1010) # 10 original due to factory, + 1000 in this test
@@ -110,7 +110,7 @@ module Spree
 
       it "can delete a line item on the order" do
         line_item = order.line_items.first
-        api_delete :destroy, :id => line_item.id
+        api_delete :destroy, id: line_item.id
         expect(response.status).to eq(204)
         order.reload
         expect(order.line_items.count).to eq(0) # 1 original due to factory, - 1 in this test
@@ -118,26 +118,27 @@ module Spree
       end
 
       context "order contents changed after shipments were created" do
-        let!(:order) { Order.create }
+        let!(:store) { create(:store) }
+        let!(:order) { Order.create(store: store) }
         let!(:line_item) { order.contents.add(product.master) }
 
         before { order.create_proposed_shipments }
 
         it "clear out shipments on create" do
           expect(order.reload.shipments).not_to be_empty
-          api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }
+          api_post :create, line_item: { variant_id: product.master.to_param, quantity: 1 }
           expect(order.reload.shipments).to be_empty
         end
 
         it "clear out shipments on update" do
           expect(order.reload.shipments).not_to be_empty
-          api_put :update, :id => line_item.id, :line_item => { :quantity => 1000 }
+          api_put :update, id: line_item.id, line_item: { quantity: 1000 }
           expect(order.reload.shipments).to be_empty
         end
 
         it "clear out shipments on delete" do
           expect(order.reload.shipments).not_to be_empty
-          api_delete :destroy, :id => line_item.id
+          api_delete :destroy, id: line_item.id
           expect(order.reload.shipments).to be_empty
         end
 
@@ -149,7 +150,7 @@ module Spree
 
           it "doesn't destroy shipments or restart checkout flow" do
             expect(order.reload.shipments).not_to be_empty
-            api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }
+            api_post :create, line_item: { variant_id: product.master.to_param, quantity: 1 }
             expect(order.reload.shipments).not_to be_empty
           end
         end
@@ -164,20 +165,20 @@ module Spree
       end
 
       it "cannot add a new line item to the order" do
-        api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }
+        api_post :create, line_item: { variant_id: product.master.to_param, quantity: 1 }
         assert_unauthorized!
       end
 
       it "cannot update a line item on the order" do
         line_item = order.line_items.first
-        api_put :update, :id => line_item.id, :line_item => { :quantity => 1000 }
+        api_put :update, id: line_item.id, line_item: { quantity: 1000 }
         assert_unauthorized!
         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
+        api_delete :destroy, id: line_item.id
         assert_unauthorized!
         expect { line_item.reload }.not_to raise_error
       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, type: :controller do
     render_views
 
     let(:attributes) { [:id, :name, :position, :presentation] }
@@ -15,7 +15,7 @@ module Spree
     def check_option_values(option_values)
       expect(option_values.count).to eq(1)
       expect(option_values.first).to have_attributes([:id, :name, :presentation,
-                                                  :option_type_name, :option_type_id])
+                                                      :option_type_name, :option_type_id])
     end
 
     it "can list all option types" do
@@ -27,47 +27,47 @@ module Spree
     end
 
     it "can search for an option type" do
-      create(:option_type, :name => "buzz")
-      api_get :index, :q => { :name_cont => option_type.name }
+      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)
     end
 
     it "can retrieve 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}"
+      create(:option_type)
+      api_get :index, ids: "#{option_type.id},#{option_type_1.id}"
       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
+      api_get :show, id: option_type.id
       expect(json_response).to have_attributes(attributes)
       check_option_values(json_response["option_values"])
     end
 
     it "cannot create a new option type" do
-      api_post :create, :option_type => {
-                        :name => "Option Type",
-                        :presentation => "Option Type"
+      api_post :create, option_type: {
+                        name: "Option Type",
+                        presentation: "Option Type"
                       }
       assert_unauthorized!
     end
 
     it "cannot alter an option type" do
       original_name = option_type.name
-      api_put :update, :id => option_type.id,
-                        :option_type => {
-                          :name => "Option Type"
+      api_put :update, id: option_type.id,
+                        option_type: {
+                          name: "Option Type"
                         }
       assert_not_found!
       expect(option_type.reload.name).to eq(original_name)
     end
 
     it "cannot delete an option type" do
-      api_delete :destroy, :id => option_type.id
+      api_delete :destroy, id: option_type.id
       assert_not_found!
       expect { option_type.reload }.not_to raise_error
     end
@@ -76,23 +76,22 @@ module Spree
       sign_in_as_admin!
 
       it "can create an option type" do
-        api_post :create, :option_type => {
-                          :name => "Option Type",
-                          :presentation => "Option Type"
+        api_post :create, option_type: {
+                          name: "Option Type",
+                          presentation: "Option Type"
                         }
         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 => {}
+        api_post :create, option_type: {}
         expect(response.status).to eq(422)
       end
 
       it "can update an option type" do
-        original_name = option_type.name
-        api_put :update, :id => option_type.id, :option_type => {
-                              :name => "Option Type",
+        api_put :update, id: option_type.id, option_type: {
+                              name: "Option Type"
                             }
         expect(response.status).to eq(200)
 
@@ -101,14 +100,14 @@ module Spree
       end
 
       it "cannot update an option type with invalid attributes" do
-        api_put :update, :id => option_type.id, :option_type => {
-                          :name => ""
+        api_put :update, id: option_type.id, option_type: {
+                          name: ""
                          }
         expect(response.status).to eq(422)
       end
 
       it "can delete an option type" do
-        api_delete :destroy, :id => option_type.id
+        api_delete :destroy, id: option_type.id
         expect(response.status).to eq(204)
       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, type: :controller do
     render_views
 
     let(:attributes) { [:id, :name, :presentation, :option_type_name, :option_type_name] }
@@ -15,13 +15,13 @@ module Spree
     def check_option_values(option_values)
       expect(option_values.count).to eq(1)
       expect(option_values.first).to have_attributes([:id, :name, :presentation,
-                                                  :option_type_name, :option_type_id])
+                                                      :option_type_name, :option_type_id])
     end
 
     context "without any option type scoping" do
       before do
         # Create another option value with a brand new option type
-        create(:option_value, :option_type => create(:option_type))
+        create(:option_value, option_type: create(:option_type))
       end
 
       it "can retrieve a list of all option values" do
@@ -32,7 +32,7 @@ module Spree
     end
 
     context "for a particular option type" do
-      let(:resource_scoping) { { :option_type_id => option_type.id } }
+      let(:resource_scoping) { { option_type_id: option_type.id } }
 
       it "can list all option values" do
         api_get :index
@@ -41,44 +41,44 @@ module Spree
       end
 
       it "can search for an option type" do
-        create(:option_value, :name => "buzz")
-        api_get :index, :q => { :name_cont => option_value.name }
+        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)
       end
 
       it "can retrieve 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]
+        option_value_1 = create(:option_value, option_type: option_type)
+        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)
       end
 
       it "can list a single option value" do
-        api_get :show, :id => option_value.id
+        api_get :show, id: option_value.id
         expect(json_response).to have_attributes(attributes)
       end
 
       it "cannot create a new option value" do
-        api_post :create, :option_value => {
-                          :name => "Option Value",
-                          :presentation => "Option Value"
+        api_post :create, option_value: {
+                          name: "Option Value",
+                          presentation: "Option Value"
                         }
         assert_unauthorized!
       end
 
       it "cannot alter an option value" do
         original_name = option_type.name
-        api_put :update, :id => option_type.id,
-                          :option_value => {
-                            :name => "Option Value"
+        api_put :update, id: option_type.id,
+                          option_value: {
+                            name: "Option Value"
                           }
         assert_not_found!
         expect(option_type.reload.name).to eq(original_name)
       end
 
       it "cannot delete an option value" do
-        api_delete :destroy, :id => option_type.id
+        api_delete :destroy, id: option_type.id
         assert_not_found!
         expect { option_type.reload }.not_to raise_error
       end
@@ -87,23 +87,22 @@ module Spree
         sign_in_as_admin!
 
         it "can create an option value" do
-          api_post :create, :option_value => {
-                            :name => "Option Value",
-                            :presentation => "Option Value"
+          api_post :create, option_value: {
+                            name: "Option Value",
+                            presentation: "Option Value"
                           }
           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_value => {}
+          api_post :create, option_value: {}
           expect(response.status).to eq(422)
         end
 
         it "can update an option value" do
-          original_name = option_value.name
-          api_put :update, :id => option_value.id, :option_value => {
-                                :name => "Option Value",
+          api_put :update, id: option_value.id, option_value: {
+                                name: "Option Value"
                               }
           expect(response.status).to eq(200)
 
@@ -113,20 +112,20 @@ module Spree
 
         it "permits the correct attributes" do
           expect(controller).to receive(:permitted_option_value_attributes)
-          api_put :update, :id => option_value.id, :option_value => {
-                            :name => ""
+          api_put :update, id: option_value.id, option_value: {
+                            name: ""
                            }
         end
 
         it "cannot update an option value with invalid attributes" do
-          api_put :update, :id => option_value.id, :option_value => {
-                            :name => ""
+          api_put :update, id: option_value.id, option_value: {
+                            name: ""
                            }
           expect(response.status).to eq(422)
         end
 
         it "can delete an option value" do
-          api_delete :destroy, :id => option_value.id
+          api_delete :destroy, id: option_value.id
           expect(response.status).to eq(204)
         end
       end