spree_api 1.3.5 → 2.0.0.rc1

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

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'spree/promo/coupon_applicator'
 
 module Spree
   describe Api::CheckoutsController do
@@ -11,8 +12,9 @@ module Spree
       @state = create(:state)
       @country = @state.country
       country_zone.members.create(:zoneable => @country)
+      create(:stock_location)
 
-      @shipping_method = create(:shipping_method, :zone => country_zone)
+      @shipping_method = create(:shipping_method, :zones => [country_zone])
       @payment_method = create(:payment_method)
     end
 
@@ -44,7 +46,7 @@ module Spree
     end
 
     context "PUT 'update'" do
-      let(:order) { create(:order) }
+      let(:order) { create(:order_with_line_items) }
 
       before(:each) do
         Order.any_instance.stub(:confirmation_required? => true)
@@ -53,26 +55,24 @@ module Spree
 
       it "will return an error if the recently created order cannot transition from cart to address" do
         order.state.should eq "cart"
-        order.email = nil # email is necessary to transition from cart to address
-        order.save!
+        order.update_column(:email, nil) # email is necessary to transition from cart to address
 
-        api_put :update, :id => order.to_param, :order_token => order.token
+        api_put :update, :id => order.to_param
 
-        json_response['error'].should =~ /could not be transitioned/
-        response.status.should == 422
+        # Order has not transitioned
+        json_response['state'].should == 'cart'
       end
 
       it "should transition a recently created order from cart do address" do
         order.state.should eq "cart"
         order.email.should_not be_nil
-        api_put :update, :id => order.to_param, :order_token => order.token
+        api_put :update, :id => order.to_param
         order.reload.state.should eq "address"
       end
 
       it "will return an error if the order cannot transition" do
         order.update_column(:state, "address")
-        api_put :update, :id => order.to_param, :order_token => order.token
-        json_response['error'].should =~ /could not be transitioned/
+        api_put :update, :id => order.to_param
         response.status.should == 422
       end
 
@@ -89,9 +89,8 @@ module Spree
           :country_id => @country.id
         }
         api_put :update,
-                :id => order.to_param, :order_token => order.token,
+                :id => order.to_param,
                 :order => { :bill_address_attributes => billing_address, :ship_address_attributes => shipping_address }
-
         json_response['state'].should == 'delivery'
         json_response['bill_address']['firstname'].should == 'John'
         json_response['ship_address']['firstname'].should == 'John'
@@ -100,9 +99,9 @@ module Spree
 
       it "can update shipping method and transition from delivery to payment" do
         order.update_column(:state, "delivery")
-        api_put :update, :id => order.to_param, :order_token => order.token,
-                         :order => { :shipping_method_id => @shipping_method.id }
-
+        shipment = create(:shipment, :order => order)
+        shipping_rate = shipment.shipping_rates.first
+        api_put :update, :id => order.to_param, :order => { :shipments_attributes => { "0" => { :selected_shipping_rate_id => shipping_rate.id, :id => shipment.id } } }
         json_response['shipments'][0]['shipping_method']['name'].should == @shipping_method.name
         json_response['state'].should == 'payment'
         response.status.should == 200
@@ -110,8 +109,7 @@ module Spree
 
       it "can update payment method and transition from payment to confirm" do
         order.update_column(:state, "payment")
-        api_put :update, :id => order.to_param, :order_token => order.token,
-                         :order => { :payments_attributes => [{ :payment_method_id => @payment_method.id }] }
+        api_put :update, :id => order.to_param, :order => { :payments_attributes => [{ :payment_method_id => @payment_method.id }] }
         json_response['state'].should == 'confirm'
         json_response['payments'][0]['payment_method']['name'].should == @payment_method.name
         response.status.should == 200
@@ -120,34 +118,67 @@ module Spree
       it "can transition from confirm to complete" do
         order.update_column(:state, "confirm")
         Spree::Order.any_instance.stub(:payment_required? => false)
-        api_put :update, :id => order.to_param, :order_token => order.token
+        api_put :update, :id => order.to_param
         json_response['state'].should == 'complete'
         response.status.should == 200
       end
 
       it "returns the order if the order is already complete" do
         order.update_column(:state, "complete")
-        api_put :update, :id => order.to_param, :order_token => order.token
+        api_put :update, :id => order.to_param
         json_response['number'].should == order.number
         response.status.should == 200
       end
 
-      it "can assign a user to the order" do
-        user = create(:user)
-        api_put :update, :id => order.to_param, :order_token => order.token, :order => { :user_id => user.id }
-        json_response['user_id'].should == user.id
-        response.status.should == 200
+      context "as an admin" do
+        sign_in_as_admin!
+        it "can assign a user to the order" do
+          user = create(:user)
+          # Need to pass email as well so that validations succeed
+          api_put :update, :id => order.to_param, :order => { :user_id => user.id, :email => "guest@spreecommerce.com" }
+          response.status.should == 200
+          json_response['user_id'].should == user.id
+        end
       end
 
       it "can assign an email to the order" do
-        api_put :update, :id => order.to_param, :order_token => order.token, :order => { :email => "guest@spreecommerce.com" }
+        api_put :update, :id => order.to_param, :order => { :email => "guest@spreecommerce.com" }
         json_response['email'].should == "guest@spreecommerce.com"
         response.status.should == 200
       end
 
-      it "cannot update an order without authorization" do
-        api_put :update, :id => order.to_param
-        assert_unauthorized!
+      it "can apply a coupon code to an order" do
+        order.update_column(:state, "payment")
+        Spree::Promo::CouponApplicator.should_receive(:new).with(order).and_call_original
+        Spree::Promo::CouponApplicator.any_instance.should_receive(:apply).and_return({:coupon_applied? => true})
+        api_put :update, :id => order.to_param, :order => { :coupon_code => "foobar" }
+      end
+    end
+
+    context "PUT 'next'" do
+      let!(:order) { create(:order) }
+      it "can transition an order to the next state" do
+        order.update_column(:email, "spree@example.com")
+
+        api_put :next, :id => order.to_param
+        response.status.should == 200
+        json_response['state'].should == 'address'
+      end
+
+      it "cannot transition if order email is blank" do
+        order.update_column(:email, nil)
+
+        api_put :next, :id => order.to_param
+        response.status.should == 422
+        json_response['error'].should =~ /could not be transitioned/
+      end
+
+      it "can apply a coupon code to an order" do
+        order.update_column(:state, "payment")
+        Spree::Promo::CouponApplicator.should_receive(:new).with(order).and_call_original
+        coupon_result = { :coupon_applied? => true }
+        Spree::Promo::CouponApplicator.any_instance.should_receive(:apply).and_return(coupon_result)
+        api_put :update, :id => order.to_param, :order => { :coupon_code => "foobar" }
       end
     end
   end

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

@@ -4,11 +4,7 @@ module Spree
   describe Api::LineItemsController do
     render_views
 
-    let!(:order) do
-     order = create(:order)
-     order.line_items << create(:line_item)
-     order
-    end
+    let!(:order) { create(:order_with_line_items) }
 
     let(:product) { create(:product) }
     let(:attributes) { [:id, :quantity, :price, :variant] }

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

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module Spree
+  describe Api::OptionTypesController do
+    render_views
+
+    let(:attributes) { [:id, :name, :position, :presentation] }
+    let!(:option_value) { create(:option_value) }
+    let!(:option_type) { option_value.option_type }
+
+    before do
+      stub_authentication!
+    end
+
+    def check_option_values(option_values)
+      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
+      json_response.count.should == 1
+      json_response.first.should have_attributes(attributes)
+
+      check_option_values(json_response.first["option_values"])
+    end
+
+    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)
+    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
+
+      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)
+      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"
+                      }
+      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"
+                        }
+      assert_unauthorized!
+      option_type.reload.name.should == original_name
+    end
+
+    it "cannot delete an option type" do
+      api_delete :destroy, :id => option_type.id
+      assert_unauthorized!
+      lambda { option_type.reload }.should_not raise_error(ActiveRecord::RecordNotFound)
+    end
+
+    context "as an admin" do
+      sign_in_as_admin!
+
+      it "can create an option type" do
+        api_post :create, :option_type => {
+                          :name => "Option Type",
+                          :presentation => "Option Type"
+                        }
+        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 => {}
+        response.status.should == 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",
+                            }
+        response.status.should == 200
+
+        option_type.reload
+        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 => ""
+                         }
+        response.status.should == 422
+      end
+
+      it "can delete an option type" do
+        api_delete :destroy, :id => option_type.id
+        response.status.should == 204
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+module Spree
+  describe Api::OptionValuesController do
+    render_views
+
+    let(:attributes) { [:id, :name, :presentation, :option_type_name, :option_type_name] }
+    let!(:option_value) { create(:option_value) }
+    let!(:option_type) { option_value.option_type }
+
+    before do
+      stub_authentication!
+    end
+
+    def check_option_values(option_values)
+      option_values.count.should == 1
+      option_values.first.should have_attributes([:id, :name, :presentation,
+                                                  :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))
+      end
+
+      it "can retreive a list of all option values" do
+        api_get :index
+        json_response.count.should == 2
+        json_response.first.should have_attributes(attributes)
+      end
+    end
+
+    context "for a particular option type" do
+      let(:resource_scoping) { { :option_type_id => option_type.id } }
+
+      it "can list all option values" do
+        api_get :index
+        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 }
+        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]
+        json_response.count.should == 2
+      end
+
+      it "can list a single option value" do
+        api_get :show, :id => option_value.id
+        json_response.should have_attributes(attributes)
+      end
+
+      it "cannot create a new option value" do
+        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"
+                          }
+        assert_unauthorized!
+        option_type.reload.name.should == original_name
+      end
+
+      it "cannot delete an option value" do
+        api_delete :destroy, :id => option_type.id
+        assert_unauthorized!
+        lambda { option_type.reload }.should_not raise_error(ActiveRecord::RecordNotFound)
+      end
+
+      context "as an admin" do
+        sign_in_as_admin!
+
+        it "can create an option value" do
+          api_post :create, :option_value => {
+                            :name => "Option Value",
+                            :presentation => "Option Value"
+                          }
+          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 => {}
+          response.status.should == 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",
+                              }
+          response.status.should == 200
+
+          option_value.reload
+          option_value.name.should == "Option Value"
+        end
+
+        it "cannot update an option value with invalid attributes" do
+          api_put :update, :id => option_value.id, :option_value => {
+                            :name => ""
+                           }
+          response.status.should == 422
+        end
+
+        it "can delete an option value" do
+          api_delete :destroy, :id => option_value.id
+          response.status.should == 204
+        end
+      end
+    end
+  end
+end

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

@@ -11,9 +11,10 @@ module Spree
                         :completed_at, :payment_total, :shipment_state,
                         :payment_state, :email, :special_instructions] }
 
-    let(:variant) { create(:variant) }
 
-    before { stub_authentication! }
+    before do
+      stub_authentication!
+    end
 
     it "cannot view all orders" do
       api_get :index
@@ -25,6 +26,8 @@ module Spree
       api_get :show, :id => order.to_param
       response.status.should == 200
       json_response.should have_attributes(attributes)
+      json_response["adjustments"].should be_empty
+      json_response["credit_cards"].should be_empty
     end
 
     # Regression test for #1992
@@ -63,50 +66,6 @@ module Spree
       json_response["state"].should == "cart"
     end
 
-    context "import" do
-      let(:tax_rate) { create(:tax_rate, amount: 0.05, calculator: Calculator::DefaultTax.create) }
-      let(:other_variant) { create(:variant) }
-
-      # line items come in as an array when importing orders or when
-      # creating both an order an a line item at once
-      let(:order_params) do
-        {
-          :line_items => [
-            { :variant_id => variant.to_param, :quantity => 5 },
-            { :variant_id => other_variant.to_param, :quantity => 5 }
-          ]
-        }
-      end
-
-      before do
-        Zone.stub default_tax: tax_rate.zone
-        current_api_user.stub has_spree_role?: true
-      end
-
-      it "sets channel" do
-        api_post :create, :order => { channel: "amazon" }
-        expect(json_response['channel']).to eq "amazon"
-      end
-
-      it "doesnt persist any automatic tax adjustment" do
-        expect {
-          api_post :create, :order => order_params.merge(:import => true)
-        }.not_to change { Adjustment.count }
-        expect(response.status).to eq 201
-      end
-
-      context "provides sku rather than variant id" do
-        let(:order_params) do
-          { :line_items => [{ :sku => variant.sku, :quantity => 1 }] }
-        end
-
-        it "still finds the variant by sku and persist order" do
-          api_post :create, :order => order_params
-          expect(json_response['line_items'].count).to eq 1
-        end
-      end
-    end
-
     it "can create an order without any parameters" do
       lambda { api_post :create }.should_not raise_error(NoMethodError)
       response.status.should == 201
@@ -114,25 +73,6 @@ module Spree
       json_response["state"].should == "cart"
     end
 
-    it "cannot create an order with an abitrary price for the line item" do
-      variant = create(:variant)
-      api_post :create, :order => {
-        :line_items => {
-          "0" => {
-            :variant_id => variant.to_param,
-            :quantity => 5,
-            :price => 0.44
-          }
-        }
-      }
-      response.status.should == 201
-      order = Order.last
-      order.line_items.count.should == 1
-      order.line_items.first.variant.should == variant
-      order.line_items.first.quantity.should == 5
-      order.line_items.first.price.should == order.line_items.first.variant.price
-    end
-
     context "working with an order" do
       before do
         Order.any_instance.stub :user => current_api_user
@@ -155,23 +95,10 @@ module Spree
       let(:shipping_address) { { :firstname => "Tiago", :lastname => "Motta", :address1 => "Av Paulista",
                                  :city => "Sao Paulo", :zipcode => "1234567", :phone => "12345678",
                                  :country_id => Country.first.id, :state_id => State.first.id} }
-      let!(:shipping_method) { create(:shipping_method) }
       let!(:payment_method) { create(:payment_method) }
 
-      it "can not update line item prices" do
-        order.line_items << create(:line_item)
-        api_put :update, 
-          :id => order.to_param,
-          :order => {
-            :line_items => {
-              order.line_items.first.id =>
-              { 
-                :variant_id => create(:variant).id,
-                :quantity => 2,
-                :price => 0.44
-              }
-            }
-          }
+      it "can add line items" do
+        api_put :update, :id => order.to_param, :order => { :line_items => [{:variant_id => create(:variant).id, :quantity => 2}] }
 
         response.status.should == 200
         json_response['item_total'].to_f.should_not == order.item_total.to_f
@@ -197,6 +124,7 @@ module Spree
       end
 
       it "can add shipping address" do
+        pending "need to figure out how to get shipping methods for an order"
         order.ship_address.should be_nil
 
         api_put :update, :id => order.to_param, :order => { :ship_address_attributes => shipping_address }
@@ -217,7 +145,8 @@ module Spree
 
       context "with a line item" do
         before do
-          order.line_items << create(:line_item)
+          create(:line_item, :order => order)
+          order.reload
         end
 
         it "can empty an order" do
@@ -253,14 +182,6 @@ module Spree
         end
       end
 
-      it "responds with orders updated_at with miliseconds precision" do
-        api_get :index
-        milisecond = order.updated_at.strftime("%L")
-        updated_at = json_response["orders"].first["updated_at"]
-
-        expect(updated_at.split("T").last).to have_content(milisecond)
-      end
-
       context "with two orders" do
         before { create(:order) }
 
@@ -304,10 +225,7 @@ module Spree
 
       context "can cancel an order" do
         before do
-          Spree::MailMethod.create!(
-            :environment => Rails.env,
-            :preferred_mails_from => "spree@example.com"
-          )
+          Spree::Config[:mails_from] = "spree@example.com"
 
           order.completed_at = Time.now
           order.state = 'complete'