solidus_api 1.2.3 → 1.3.0.beta1

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'shared_examples/protect_product_actions'
 
 module Spree
-  describe Spree::Api::ProductsController, :type => :controller do
+  describe Spree::Api::ProductsController, type: :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -59,7 +59,7 @@ module Spree
       end
 
       it "retrieves a list of products by id" do
-        api_get :index, :ids => [product.id]
+        api_get :index, ids: [product.id]
         expect(json_response["products"].first).to have_attributes(show_attributes)
         expect(json_response["total_count"]).to eq(1)
         expect(json_response["current_page"]).to eq(1)
@@ -78,7 +78,7 @@ module Spree
 
       it "retrieves a list of products by ids string" do
         second_product = create(:product)
-        api_get :index, :ids => [product.id, second_product.id].join(",")
+        api_get :index, ids: [product.id, second_product.id].join(",")
         expect(json_response["products"].first).to have_attributes(show_attributes)
         expect(json_response["products"][1]).to have_attributes(show_attributes)
         expect(json_response["total_count"]).to eq(2)
@@ -88,7 +88,7 @@ module Spree
       end
 
       it "does not return inactive products when queried by ids" do
-        api_get :index, :ids => [inactive_product.id]
+        api_get :index, ids: [inactive_product.id]
         expect(json_response["count"]).to eq(0)
       end
 
@@ -99,8 +99,8 @@ module Spree
 
       context "pagination" do
         it "can select the next page of products" do
-          second_product = create(:product)
-          api_get :index, :page => 2, :per_page => 1
+          create(:product)
+          api_get :index, page: 2, per_page: 1
           expect(json_response["products"].first).to have_attributes(show_attributes)
           expect(json_response["total_count"]).to eq(2)
           expect(json_response["current_page"]).to eq(2)
@@ -109,7 +109,7 @@ module Spree
 
         it 'can control the page size through a parameter' do
           create(:product)
-          api_get :index, :per_page => 1
+          api_get :index, per_page: 1
           expect(json_response['count']).to eq(1)
           expect(json_response['total_count']).to eq(2)
           expect(json_response['current_page']).to eq(1)
@@ -118,40 +118,40 @@ module Spree
       end
 
       it "can search for products" do
-        create(:product, :name => "The best product in the world")
-        api_get :index, :q => { :name_cont => "best" }
+        create(:product, name: "The best product in the world")
+        api_get :index, q: { name_cont: "best" }
         expect(json_response["products"].first).to have_attributes(show_attributes)
         expect(json_response["count"]).to eq(1)
       end
 
       it "gets a single product" do
-        product.master.images.create!(:attachment => image("thinking-cat.jpg"))
+        product.master.images.create!(attachment: image("thinking-cat.jpg"))
         product.variants.create!
-        product.variants.first.images.create!(:attachment => image("thinking-cat.jpg"))
+        product.variants.first.images.create!(attachment: image("thinking-cat.jpg"))
         product.set_property("spree", "rocks")
         product.taxons << create(:taxon)
 
-        api_get :show, :id => product.to_param
+        api_get :show, id: product.to_param
 
         expect(json_response).to have_attributes(show_attributes)
         expect(json_response['variants'].first).to have_attributes([:name,
-                                                              :is_master,
-                                                              :price,
-                                                              :images,
-                                                              :in_stock])
+                                                                    :is_master,
+                                                                    :price,
+                                                                    :images,
+                                                                    :in_stock])
 
         expect(json_response['variants'].first['images'].first).to have_attributes([:attachment_file_name,
-                                                                                :attachment_width,
-                                                                                :attachment_height,
-                                                                                :attachment_content_type,
-                                                                                :mini_url,
-                                                                                :small_url,
-                                                                                :product_url,
-                                                                                :large_url])
+                                                                                    :attachment_width,
+                                                                                    :attachment_height,
+                                                                                    :attachment_content_type,
+                                                                                    :mini_url,
+                                                                                    :small_url,
+                                                                                    :product_url,
+                                                                                    :large_url])
 
         expect(json_response["product_properties"].first).to have_attributes([:value,
-                                                                         :product_id,
-                                                                         :property_name])
+                                                                              :product_id,
+                                                                              :property_name])
 
         expect(json_response["classifications"].first).to have_attributes([:taxon_id, :position, :taxon])
         expect(json_response["classifications"].first['taxon']).to have_attributes([:id, :name, :pretty_name, :permalink, :taxonomy_id, :parent_id])
@@ -161,7 +161,7 @@ module Spree
         before { Config.track_inventory_levels = false }
 
         it "still displays valid json with total_on_hand Float::INFINITY" do
-          api_get :show, :id => product.to_param
+          api_get :show, id: product.to_param
           expect(response).to be_ok
           expect(json_response[:total_on_hand]).to eq nil
         end
@@ -170,29 +170,29 @@ module Spree
       end
 
       context "finds a product by slug first then by id" do
-        let!(:other_product) { create(:product, :slug => "these-are-not-the-droids-you-are-looking-for") }
+        let!(:other_product) { create(:product, slug: "these-are-not-the-droids-you-are-looking-for") }
 
         before do
           product.update_column(:slug, "#{other_product.id}-and-1-ways")
         end
 
         specify do
-          api_get :show, :id => product.to_param
+          api_get :show, id: product.to_param
           expect(json_response["slug"]).to match(/and-1-ways/)
           product.destroy
 
-          api_get :show, :id => other_product.id
+          api_get :show, id: other_product.id
           expect(json_response["slug"]).to match(/droids/)
         end
       end
 
       it "cannot see inactive products" do
-        api_get :show, :id => inactive_product.to_param
+        api_get :show, id: inactive_product.to_param
         assert_not_found!
       end
 
       it "returns a 404 error when it cannot find a product" do
-        api_get :show, :id => "non-existant"
+        api_get :show, id: "non-existant"
         assert_not_found!
       end
 
@@ -225,7 +225,7 @@ module Spree
       # Regression test for https://github.com/spree/spree/issues/1626
       context "deleted products" do
         before do
-          create(:product, :deleted_at => 1.day.ago)
+          create(:product, deleted_at: 1.day.ago)
         end
 
         it "does not include deleted products" do
@@ -234,26 +234,24 @@ module Spree
         end
 
         it "can include deleted products" do
-          api_get :index, :show_deleted => 1
+          api_get :index, show_deleted: 1
           expect(json_response["products"].count).to eq(3)
         end
       end
 
       describe "creating a product" do
         it "can create a new product" do
-          api_post :create, :product => { :name => "The Other Product",
-                                          :price => 19.99,
-                                          :shipping_category_id => create(:shipping_category).id }
+          api_post :create, product: { name: "The Other Product",
+                                          price: 19.99,
+                                          shipping_category_id: create(:shipping_category).id }
           expect(json_response).to have_attributes(base_attributes)
           expect(response.status).to eq(201)
         end
 
         it "creates with embedded variants" do
-          product_data.merge!({
-            variants: [attributes_for_variant, attributes_for_variant]
-          })
+          product_data[:variants] = [attributes_for_variant, attributes_for_variant]
 
-          api_post :create, :product => product_data
+          api_post :create, product: product_data
           expect(response.status).to eq 201
 
           variants = json_response['variants']
@@ -265,34 +263,30 @@ module Spree
         end
 
         it "can create a new product with embedded product_properties" do
-          product_data.merge!({
-            product_properties_attributes: [{
+          product_data[:product_properties_attributes] = [{
               property_name: "fabric",
               value: "cotton"
             }]
-          })
 
-          api_post :create, :product => product_data
+          api_post :create, product: product_data
 
           expect(json_response['product_properties'][0]['property_name']).to eq('fabric')
           expect(json_response['product_properties'][0]['value']).to eq('cotton')
         end
 
         it "can create a new product with option_types" do
-          product_data.merge!({
-            option_types: ['size', 'color']
-          })
+          product_data[:option_types] = ['size', 'color']
 
-          api_post :create, :product => product_data
+          api_post :create, product: product_data
           expect(json_response['option_types'].count).to eq(2)
         end
 
         it "creates with shipping categories" do
-          hash = { :name => "The Other Product",
-                   :price => 19.99,
-                   :shipping_category => "Free Ships" }
+          hash = { name: "The Other Product",
+                   price: 19.99,
+                   shipping_category: "Free Ships" }
 
-          api_post :create, :product => hash
+          api_post :create, product: hash
           expect(response.status).to eq 201
 
           shipping_id = ShippingCategory.find_by_name("Free Ships").id
@@ -301,14 +295,14 @@ module Spree
 
         it "puts the created product in the given taxon" do
           product_data[:taxon_ids] = taxon_1.id.to_s
-          api_post :create, :product => product_data
-          expect(json_response["taxon_ids"]).to eq([taxon_1.id,])
+          api_post :create, product: product_data
+          expect(json_response["taxon_ids"]).to eq([taxon_1.id])
         end
 
         # Regression test for https://github.com/spree/spree/issues/4123
         it "puts the created product in the given taxons" do
           product_data[:taxon_ids] = [taxon_1.id, taxon_2.id].join(',')
-          api_post :create, :product => product_data
+          api_post :create, product: product_data
           expect(json_response["taxon_ids"]).to eq([taxon_1.id, taxon_2.id])
         end
 
@@ -323,7 +317,7 @@ module Spree
           end
 
           it "can still create a product" do
-            api_post :create, :product => product_data, :token => "fake"
+            api_post :create, product: product_data, token: "fake"
             expect(json_response).to have_attributes(show_attributes)
             expect(response.status).to eq(201)
           end
@@ -340,22 +334,22 @@ module Spree
 
       context 'updating a product' do
         it "can update a product" do
-          api_put :update, :id => product.to_param, :product => { :name => "New and Improved Product!" }
+          api_put :update, id: product.to_param, product: { name: "New and Improved Product!" }
           expect(response.status).to eq(200)
         end
 
         it "can create new option types on a product" do
-          api_put :update, :id => product.to_param, :product => { :option_types => ['shape', 'color'] }
+          api_put :update, id: product.to_param, product: { option_types: ['shape', 'color'] }
           expect(json_response['option_types'].count).to eq(2)
         end
 
         it "can create new variants on a product" do
-          api_put :update, :id => product.to_param, :product => { :variants => [attributes_for_variant, attributes_for_variant.merge(sku: "ABC-#{Kernel.rand(9999)}")] }
+          api_put :update, id: product.to_param, product: { variants: [attributes_for_variant, attributes_for_variant.merge(sku: "ABC-#{Kernel.rand(9999)}")] }
           expect(response.status).to eq 200
           expect(json_response['variants'].count).to eq(2) # 2 variants
 
           variants = json_response['variants'].select { |v| !v['is_master'] }
-          size_option_value = variants.last['option_values'].detect{|x| x['option_type_name'] == 'size' }
+          size_option_value = variants.last['option_values'].detect{ |x| x['option_type_name'] == 'size' }
           expect(size_option_value['name']).to eq('small')
 
           expect(json_response['option_types'].count).to eq(2) # size, color
@@ -363,16 +357,16 @@ module Spree
 
         it "can update an existing variant on a product" do
           variant_hash = {
-            :sku => '123', :price => 19.99, :options => [{:name => "size", :value => "small"}]
+            sku: '123', price: 19.99, options: [{ name: "size", value: "small" }]
           }
           variant_id = product.variants.create!({ product: product }.merge(variant_hash)).id
 
-          api_put :update, :id => product.to_param, :product => {
-            :variants => [
+          api_put :update, id: product.to_param, product: {
+            variants: [
               variant_hash.merge(
-                :id => variant_id.to_s,
-                :sku => '456',
-                :options => [{:name => "size", :value => "large" }]
+                id: variant_id.to_s,
+                sku: '456',
+                options: [{ name: "size", value: "large" }]
               )
             ]
           }
@@ -385,7 +379,7 @@ module Spree
         end
 
         it "cannot update a product with an invalid attribute" do
-          api_put :update, :id => product.to_param, :product => { :name => "" }
+          api_put :update, id: product.to_param, product: { name: "" }
           expect(response.status).to eq(422)
           expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
           expect(json_response["errors"]["name"]).to eq(["can't be blank"])
@@ -393,20 +387,20 @@ module Spree
 
         # Regression test for https://github.com/spree/spree/issues/4123
         it "puts the created product in the given taxon" do
-          api_put :update, :id => product.to_param, :product => {:taxon_ids => taxon_1.id.to_s}
+          api_put :update, id: product.to_param, product: { taxon_ids: taxon_1.id.to_s }
           expect(json_response["taxon_ids"]).to eq([taxon_1.id])
         end
 
         # Regression test for https://github.com/spree/spree/issues/4123
         it "puts the created product in the given taxons" do
-          api_put :update, :id => product.to_param, :product => {:taxon_ids => [taxon_1.id, taxon_2.id].join(',')}
+          api_put :update, id: product.to_param, product: { taxon_ids: [taxon_1.id, taxon_2.id].join(',') }
           expect(json_response["taxon_ids"]).to match_array([taxon_1.id, taxon_2.id])
         end
       end
 
       it "can delete a product" do
         expect(product.deleted_at).to be_nil
-        api_delete :destroy, :id => product.to_param
+        api_delete :destroy, id: product.to_param
         expect(response.status).to eq(204)
         expect(product.reload.deleted_at).not_to be_nil
       end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree::Api
-  describe OrdersController, :type => :controller do
+  describe OrdersController, type: :controller do
     render_views
 
     before do
@@ -9,7 +9,7 @@ module Spree::Api
     end
 
     context "with an available promotion" do
-      let!(:order) { create(:order_with_line_items, :line_items_count => 1) }
+      let!(:order) { create(:order_with_line_items, line_items_count: 1) }
       let!(:promotion) do
         promotion = create(:promotion, name: "10% off", code: "10off")
         calculator = Spree::Calculator::FlatPercentItemTotal.create(preferred_flat_percent: "10")
@@ -20,7 +20,7 @@ module Spree::Api
 
       it "can apply a coupon code to the order" do
         expect(order.total).to eq(110.00)
-        api_put :apply_coupon_code, :id => order.to_param, :coupon_code => "10off", :order_token => order.guest_token
+        api_put :apply_coupon_code, id: order.to_param, coupon_code: "10off", order_token: order.guest_token
         expect(response.status).to eq(200)
         expect(order.reload.total).to eq(109.00)
         expect(json_response["success"]).to eq("The coupon code was successfully applied to your order.")
@@ -37,7 +37,7 @@ module Spree::Api
         end
 
         it "fails to apply" do
-          api_put :apply_coupon_code, :id => order.to_param, :coupon_code => "10off", :order_token => order.guest_token
+          api_put :apply_coupon_code, id: order.to_param, coupon_code: "10off", order_token: order.guest_token
           expect(response.status).to eq(422)
           expect(json_response["success"]).to be_blank
           expect(json_response["error"]).to eq("The coupon code is expired")

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::PromotionsController, :type => :controller do
+  describe Spree::Api::PromotionsController, type: :controller do
     render_views
 
     shared_examples "a JSON response" do

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

@@ -1,10 +1,10 @@
 require 'spec_helper'
 module Spree
-  describe Spree::Api::PropertiesController, :type => :controller do
+  describe Spree::Api::PropertiesController, type: :controller do
     render_views
 
-    let!(:property_1) { Property.create!(:name => "foo", :presentation => "Foo") }
-    let!(:property_2) { Property.create!(:name => "bar", :presentation => "Bar") }
+    let!(:property_1) { Property.create!(name: "foo", presentation: "Foo") }
+    let!(:property_2) { Property.create!(name: "bar", presentation: "Bar") }
 
     let(:attributes) { [:id, :name, :presentation] }
 
@@ -19,38 +19,38 @@ module Spree
     end
 
     it "can control the page size through a parameter" do
-      api_get :index, :per_page => 1
+      api_get :index, per_page: 1
       expect(json_response['properties'].count).to eq(1)
       expect(json_response['current_page']).to eq(1)
       expect(json_response['pages']).to eq(2)
     end
 
     it 'can query the results through a parameter' do
-      api_get :index, :q => { :name_cont => 'ba' }
+      api_get :index, q: { name_cont: 'ba' }
       expect(json_response['count']).to eq(1)
       expect(json_response['properties'].first['presentation']).to eq property_2.presentation
     end
 
     it "retrieves a list of properties by id" do
-      api_get :index, :ids => [property_1.id]
+      api_get :index, ids: [property_1.id]
       expect(json_response["properties"].first).to have_attributes(attributes)
       expect(json_response["count"]).to eq(1)
     end
 
     it "retrieves a list of properties by ids string" do
-      api_get :index, :ids => [property_1.id, property_2.id].join(",")
+      api_get :index, ids: [property_1.id, property_2.id].join(",")
       expect(json_response["properties"].first).to have_attributes(attributes)
       expect(json_response["properties"][1]).to have_attributes(attributes)
       expect(json_response["count"]).to eq(2)
     end
 
     it "can see a single property" do
-      api_get :show, :id => property_1.id
+      api_get :show, id: property_1.id
       expect(json_response).to have_attributes(attributes)
     end
 
     it "can see a property by name" do
-      api_get :show, :id => property_1.name
+      api_get :show, id: property_1.name
       expect(json_response).to have_attributes(attributes)
     end
 
@@ -61,17 +61,17 @@ module Spree
     end
 
     it "cannot create a new property if not an admin" do
-      api_post :create, :property => { :name => "My Property 3" }
+      api_post :create, property: { name: "My Property 3" }
       assert_unauthorized!
     end
 
     it "cannot update a property" do
-      api_put :update, :id => property_1.name, :property => { :presentation => "my value 456" }
+      api_put :update, id: property_1.name, property: { presentation: "my value 456" }
       assert_unauthorized!
     end
 
     it "cannot delete a property" do
-      api_delete :destroy, :id => property_1.id
+      api_delete :destroy, id: property_1.id
       assert_unauthorized!
       expect { property_1.reload }.not_to raise_error
     end
@@ -81,19 +81,19 @@ module Spree
 
       it "can create a new property" do
         expect(Spree::Property.count).to eq(2)
-        api_post :create, :property => { :name => "My Property 3", :presentation => "my value 3" }
+        api_post :create, property: { name: "My Property 3", presentation: "my value 3" }
         expect(json_response).to have_attributes(attributes)
         expect(response.status).to eq(201)
         expect(Spree::Property.count).to eq(3)
       end
 
       it "can update a property" do
-        api_put :update, :id => property_1.name, :property => { :presentation => "my value 456" }
+        api_put :update, id: property_1.name, property: { presentation: "my value 456" }
         expect(response.status).to eq(200)
       end
 
       it "can delete a property" do
-        api_delete :destroy, :id => property_1.name
+        api_delete :destroy, id: property_1.name
         expect(response.status).to eq(204)
         expect { property_1.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end

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

@@ -59,10 +59,39 @@ module Spree
         it "returns widgets" do
           api_get :index, token: admin_user.spree_api_key
           expect(response).to be_success
-          expect(json_response['widgets']).to include(
+          expect(json_response['widgets']).to include(hash_including(
             'name' => 'a widget',
             'position' => 1
-          )
+          ))
+        end
+
+        context "specifying ids" do
+          let!(:widget2) { Widget.create!(name: "a widget") }
+
+          it "returns both widgets from comma separated string" do
+            api_get :index, ids: [widget.id, widget2.id].join(','), token: admin_user.spree_api_key
+            expect(response).to be_success
+            expect(json_response['widgets'].size).to eq 2
+          end
+
+          it "returns both widgets from multiple arguments" do
+            api_get :index, ids: [widget.id, widget2.id], token: admin_user.spree_api_key
+            expect(response).to be_success
+            expect(json_response['widgets'].size).to eq 2
+          end
+
+          it "returns one requested widgets" do
+            api_get :index, ids: widget2.id.to_s, token: admin_user.spree_api_key
+            expect(response).to be_success
+            expect(json_response['widgets'].size).to eq 1
+            expect(json_response['widgets'][0]['id']).to eq widget2.id
+          end
+
+          it "returns no widgets if empty" do
+            api_get :index, ids: '', token: admin_user.spree_api_key
+            expect(response).to be_success
+            expect(json_response['widgets']).to be_empty
+          end
         end
       end
     end