spree_api 2.3.13 → 2.4.0.rc1

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 do
     render_views
 
     let!(:product) { create(:product) }
@@ -51,20 +51,48 @@ module Spree
 
       it "retrieves a list of products" do
         api_get :index
-        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)
-        expect(json_response["pages"]).to eq(1)
-        expect(json_response["per_page"]).to eq(Kaminari.config.default_per_page)
+        json_response["products"].first.should have_attributes(show_attributes)
+        json_response["total_count"].should == 1
+        json_response["current_page"].should == 1
+        json_response["pages"].should == 1
+        json_response["per_page"].should == Kaminari.config.default_per_page
       end
 
       it "retrieves a list of products by id" do
         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)
-        expect(json_response["pages"]).to eq(1)
-        expect(json_response["per_page"]).to eq(Kaminari.config.default_per_page)
+        json_response["products"].first.should have_attributes(show_attributes)
+        json_response["total_count"].should == 1
+        json_response["current_page"].should == 1
+        json_response["pages"].should == 1
+        json_response["per_page"].should == Kaminari.config.default_per_page
+      end
+
+      context "specifying a rabl template for a custom action" do
+        before do
+          Spree::Api::ProductsController.class_eval do
+            def custom_show
+              @product = find_product(params[:id])
+              respond_with(@product)
+            end
+          end
+        end
+
+        it "uses the specified custom template through the request header" do
+          request.headers['X-Spree-Template'] = 'show'
+          api_get :custom_show, :id => product.id
+          response.should render_template('spree/api/products/show')
+        end
+
+        it "uses the specified custom template through the template URL parameter" do
+          api_get :custom_show, :id => product.id, :template => 'show'
+          response.should render_template('spree/api/products/show')
+        end
+
+        it "falls back to the default template if the specified template does not exist" do
+          request.headers['X-Spree-Template'] = 'invoice'
+          api_get :show, :id => product.id
+          response.should render_template('spree/api/products/show')
+        end
       end
 
       context "product has more than one price" do
@@ -79,49 +107,64 @@ 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(",")
-        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)
-        expect(json_response["current_page"]).to eq(1)
-        expect(json_response["pages"]).to eq(1)
-        expect(json_response["per_page"]).to eq(Kaminari.config.default_per_page)
+        json_response["products"].first.should have_attributes(show_attributes)
+        json_response["products"][1].should have_attributes(show_attributes)
+        json_response["total_count"].should == 2
+        json_response["current_page"].should == 1
+        json_response["pages"].should == 1
+        json_response["per_page"].should == Kaminari.config.default_per_page
       end
 
       it "does not return inactive products when queried by ids" do
         api_get :index, :ids => [inactive_product.id]
-        expect(json_response["count"]).to eq(0)
+        json_response["count"].should == 0
       end
 
       it "does not list unavailable products" do
         api_get :index
-        expect(json_response["products"].first["name"]).not_to eq("inactive")
+        json_response["products"].first["name"].should_not eq("inactive")
       end
 
       context "pagination" do
         it "can select the next page of products" do
           second_product = 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)
-          expect(json_response["pages"]).to eq(2)
+          json_response["products"].first.should have_attributes(show_attributes)
+          json_response["total_count"].should == 2
+          json_response["current_page"].should == 2
+          json_response["pages"].should == 2
         end
 
         it 'can control the page size through a parameter' do
           create(:product)
           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)
-          expect(json_response['pages']).to eq(2)
+          json_response['count'].should == 1
+          json_response['total_count'].should == 2
+          json_response['current_page'].should == 1
+          json_response['pages'].should == 2
+        end
+      end
+
+      context "jsonp" do
+        it "retrieves a list of products of jsonp" do
+          api_get :index, {:callback => 'callback'}
+          response.body.should =~ /^callback\(.*\)$/
+          response.header['Content-Type'].should include('application/javascript')
+        end
+
+        # Regression test for #4332
+        it "does not escape quotes" do
+          api_get :index, {:callback => 'callback'}
+          response.body.should =~ /^callback\({"count":1,"total_count":1/
+          response.header['Content-Type'].should include('application/javascript')
         end
       end
 
       it "can search for products" do
         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)
+        json_response["products"].first.should have_attributes(show_attributes)
+        json_response["count"].should == 1
       end
 
       it "gets a single product" do
@@ -130,14 +173,14 @@ module Spree
         product.variants.first.images.create!(:attachment => image("thinking-cat.jpg"))
         product.set_property("spree", "rocks")
         api_get :show, :id => product.to_param
-        expect(json_response).to have_attributes(show_attributes)
-        expect(json_response['variants'].first).to have_attributes([:name,
+        json_response.should have_attributes(show_attributes)
+        json_response['variants'].first.should have_attributes([:name,
                                                               :is_master,
                                                               :price,
                                                               :images,
                                                               :in_stock])
 
-        expect(json_response['variants'].first['images'].first).to have_attributes([:attachment_file_name,
+        json_response['variants'].first['images'].first.should have_attributes([:attachment_file_name,
                                                                                 :attachment_width,
                                                                                 :attachment_height,
                                                                                 :attachment_content_type,
@@ -146,7 +189,7 @@ module Spree
                                                                                 :product_url,
                                                                                 :large_url])
 
-        expect(json_response["product_properties"].first).to have_attributes([:value,
+        json_response["product_properties"].first.should have_attributes([:value,
                                                                          :product_id,
                                                                          :property_name])
       end
@@ -172,11 +215,11 @@ module Spree
 
         specify do
           api_get :show, :id => product.to_param
-          expect(json_response["slug"]).to match(/and-1-ways/)
+          json_response["slug"].should =~ /and-1-ways/
           product.destroy
 
           api_get :show, :id => other_product.id
-          expect(json_response["slug"]).to match(/droids/)
+          json_response["slug"].should =~ /droids/
         end
       end
 
@@ -192,11 +235,11 @@ module Spree
 
       it "can learn how to create a new product" do
         api_get :new
-        expect(json_response["attributes"]).to eq(new_attributes.map(&:to_s))
+        json_response["attributes"].should == new_attributes.map(&:to_s)
         required_attributes = json_response["required_attributes"]
-        expect(required_attributes).to include("name")
-        expect(required_attributes).to include("price")
-        expect(required_attributes).to include("shipping_category_id")
+        required_attributes.should include("name")
+        required_attributes.should include("price")
+        required_attributes.should include("shipping_category_id")
       end
 
       it_behaves_like "modifying product actions are restricted"
@@ -210,10 +253,10 @@ module Spree
 
       it "can see all products" do
         api_get :index
-        expect(json_response["products"].count).to eq(2)
-        expect(json_response["count"]).to eq(2)
-        expect(json_response["current_page"]).to eq(1)
-        expect(json_response["pages"]).to eq(1)
+        json_response["products"].count.should == 2
+        json_response["count"].should == 2
+        json_response["current_page"].should == 1
+        json_response["pages"].should == 1
       end
 
       # Regression test for #1626
@@ -224,12 +267,12 @@ module Spree
 
         it "does not include deleted products" do
           api_get :index
-          expect(json_response["products"].count).to eq(2)
+          json_response["products"].count.should == 2
         end
 
         it "can include deleted products" do
           api_get :index, :show_deleted => 1
-          expect(json_response["products"].count).to eq(3)
+          json_response["products"].count.should == 3
         end
       end
 
@@ -238,8 +281,8 @@ module Spree
           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)
+          json_response.should have_attributes(base_attributes)
+          response.status.should == 201
         end
 
         it "creates with embedded variants" do
@@ -318,25 +361,25 @@ module Spree
 
           it "can still create a product" do
             api_post :create, :product => product_data, :token => "fake"
-            expect(json_response).to have_attributes(show_attributes)
-            expect(response.status).to eq(201)
+            json_response.should have_attributes(show_attributes)
+            response.status.should == 201
           end
         end
 
         it "cannot create a new product with invalid attributes" do
-          api_post :create, product: {}
-          expect(response.status).to eq(422)
-          expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
+          api_post :create, :product => {}
+          response.status.should == 422
+          json_response["error"].should == "Invalid resource. Please fix errors and try again."
           errors = json_response["errors"]
           errors.delete("slug") # Don't care about this one.
-          expect(errors.keys).to match_array(["name", "price", "shipping_category_id"])
+          errors.keys.should =~ ["name", "price", "shipping_category_id"]
         end
       end
 
       context 'updating a product' do
         it "can update a product" do
           api_put :update, :id => product.to_param, :product => { :name => "New and Improved Product!" }
-          expect(response.status).to eq(200)
+          response.status.should == 200
         end
 
         it "can create new option types on a product" do
@@ -381,9 +424,9 @@ module Spree
 
         it "cannot update a product with an invalid attribute" do
           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"])
+          response.status.should == 422
+          json_response["error"].should == "Invalid resource. Please fix errors and try again."
+          json_response["errors"]["name"].should == ["can't be blank"]
         end
 
         # Regression test for #4123
@@ -400,10 +443,10 @@ module Spree
       end
 
       it "can delete a product" do
-        expect(product.deleted_at).to be_nil
+        product.deleted_at.should be_nil
         api_delete :destroy, :id => product.to_param
-        expect(response.status).to eq(204)
-        expect(product.reload.deleted_at).not_to be_nil
+        response.status.should == 204
+        product.reload.deleted_at.should_not be_nil
       end
     end
   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 do
     render_views
 
     before do
@@ -10,7 +10,7 @@ module Spree::Api
 
     context "with an available promotion" do
       let!(:order) { create(:order_with_line_items, :line_items_count => 1) }
-      let!(:promotion) do
+      let!(:promotion) do 
         promotion = Spree::Promotion.create(name: "10% off", code: "10off")
         calculator = Spree::Calculator::FlatPercentItemTotal.create(preferred_flat_percent: "10")
         action = Spree::Promotion::Actions::CreateItemAdjustments.create(calculator: calculator)
@@ -19,13 +19,14 @@ module Spree::Api
       end
 
       it "can apply a coupon code to the order" do
-        expect(order.total).to eq(110.00)
+        order.total.should == 110.00
         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.")
-        expect(json_response["error"]).to be_blank
-        expect(json_response["successful"]).to be true
+        response.status.should == 200
+        order.reload.total.should == 109.00
+        json_response["success"].should == "The coupon code was successfully applied to your order."
+        json_response["error"].should be_blank
+        json_response["successful"].should be true
+        json_response["status_code"].should eq("coupon_code_applied")
       end
 
       context "with an expired promotion" do
@@ -37,10 +38,11 @@ module Spree::Api
 
         it "fails to apply" do
           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")
-          expect(json_response["successful"]).to be false
+          response.status.should == 422
+          json_response["success"].should be_blank
+          json_response["error"].should == "The coupon code is expired"
+          json_response["successful"].should be false
+          json_response["status_code"].should eq("coupon_code_expired")
         end
       end
     end

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

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module Spree
+  describe Spree::Api::PromotionsController do
+    render_views
+
+    shared_examples "a JSON response" do
+      it 'should be ok' do
+        expect(subject).to be_ok
+      end
+
+      it 'should return JSON' do
+        payload = HashWithIndifferentAccess.new(JSON.parse(subject.body))
+        expect(payload).to_not be_nil
+        Spree::Api::ApiHelpers.promotion_attributes.each do |attribute|
+          expect(payload.has_key?(attribute)).to be true
+        end
+      end
+    end
+
+    before do
+      stub_authentication!
+    end
+
+    let(:promotion) { create :promotion, code: '10off' }
+
+    describe 'GET #show' do
+      subject { api_get :show, id: id }
+
+      context 'when admin' do
+        sign_in_as_admin!
+
+        context 'when finding by id' do
+          let(:id) { promotion.id }
+
+          it_behaves_like "a JSON response"
+        end
+
+        context 'when finding by code' do
+          let(:id) { promotion.code }
+
+          it_behaves_like "a JSON response"
+        end
+
+        context 'when id does not exist' do
+          let(:id) { 'argh' }
+
+          it 'should be 404' do
+            expect(subject.status).to eq(404)
+          end
+        end
+      end
+
+      context 'when non admin' do
+        let(:id) { promotion.id }
+
+        it 'should be unauthorized' do
+          subject
+          assert_unauthorized!
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 module Spree
-  describe Spree::Api::PropertiesController, :type => :controller do
+  describe Spree::Api::PropertiesController do
     render_views
 
     let!(:property_1) { Property.create!(:name => "foo", :presentation => "Foo") }
@@ -14,50 +14,50 @@ module Spree
 
     it "can see a list of all properties" do
       api_get :index
-      expect(json_response["properties"].count).to eq(2)
-      expect(json_response["properties"].first).to have_attributes(attributes)
+      json_response["properties"].count.should eq(2)
+      json_response["properties"].first.should have_attributes(attributes)
     end
 
     it "can control the page size through a parameter" do
       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)
+      json_response['properties'].count.should == 1
+      json_response['current_page'].should == 1
+      json_response['pages'].should == 2
     end
 
     it 'can query the results through a parameter' do
       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
+      json_response['count'].should == 1
+      json_response['properties'].first['presentation'].should eq property_2.presentation
     end
 
     it "retrieves a list of properties by id" do
       api_get :index, :ids => [property_1.id]
-      expect(json_response["properties"].first).to have_attributes(attributes)
-      expect(json_response["count"]).to eq(1)
+      json_response["properties"].first.should have_attributes(attributes)
+      json_response["count"].should == 1
     end
 
     it "retrieves a list of properties by ids string" do
       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)
+      json_response["properties"].first.should have_attributes(attributes)
+      json_response["properties"][1].should have_attributes(attributes)
+      json_response["count"].should == 2
     end
 
     it "can see a single property" do
       api_get :show, :id => property_1.id
-      expect(json_response).to have_attributes(attributes)
+      json_response.should have_attributes(attributes)
     end
 
     it "can see a property by name" do
       api_get :show, :id => property_1.name
-      expect(json_response).to have_attributes(attributes)
+      json_response.should have_attributes(attributes)
     end
 
     it "can learn how to create a new property" do
       api_get :new
-      expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
-      expect(json_response["required_attributes"]).to be_empty
+      json_response["attributes"].should == attributes.map(&:to_s)
+      json_response["required_attributes"].should be_empty
     end
 
     it "cannot create a new property if not an admin" do
@@ -73,29 +73,29 @@ module Spree
     it "cannot delete a property" do
       api_delete :destroy, :id => property_1.id
       assert_unauthorized!
-      expect { property_1.reload }.not_to raise_error
+      lambda { property_1.reload }.should_not raise_error
     end
 
     context "as an admin" do
       sign_in_as_admin!
 
       it "can create a new property" do
-        expect(Spree::Property.count).to eq(2)
+        Spree::Property.count.should == 2
         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)
+        json_response.should have_attributes(attributes)
+        response.status.should == 201
+        Spree::Property.count.should == 3
       end
 
       it "can update a property" do
         api_put :update, :id => property_1.name, :property => { :presentation => "my value 456" }
-        expect(response.status).to eq(200)
+        response.status.should == 200
       end
 
       it "can delete a property" do
         api_delete :destroy, :id => property_1.name
-        expect(response.status).to eq(204)
-        expect { property_1.reload }.to raise_error(ActiveRecord::RecordNotFound)
+        response.status.should == 204
+        lambda { property_1.reload }.should raise_error(ActiveRecord::RecordNotFound)
       end
     end
   end