spree_api 1.3.3 → 1.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f397d8160397db229e68ecb1625d2a70c704abb6
-  data.tar.gz: d21c61fe36137fccefe8d0a21d3904b658a82943
+  metadata.gz: 288706a5a4c81fc84a82d1f1aa91dcd8ce546fb6
+  data.tar.gz: 75057c9776f7ecbe0374da3d4c155aa3bf61130d
 SHA512:
-  metadata.gz: fbc700d85f13b92900aedee047f0406ace478aa353fc3c283600bb40bd48e7fe121c555191d900df92fc55bdb0a01d3b9b11884603093f88fa7b56928c90898c
-  data.tar.gz: 206781bde534695d6a1d56584560d3355b08d4582d36f0dede3b748b471ca951a4b7cb5ba950fc072290acb40f5ea69177313ae0e4f3b07d80ea0968cb1bd5d5
+  metadata.gz: 83df37343d301ff95eb8f78144c36d6a0b88703f704400510dedf050b511482339e731b1396d3312012cbbcaeb843451bed73f3a8e257b6305d61859c9665c83
+  data.tar.gz: e88252e0d65aeee9ffcefab0b9c18bc088068881f7f42787615e1094c26fa076c3377cf4bb4c4f591edaf987b325b5b1321d3993ce82d2a4e5d69593c01077df

data/app/controllers/spree/api/checkouts_controller.rb

@@ -4,8 +4,14 @@ module Spree
       before_filter :load_order, :only => :update
       before_filter :associate_user, :only => :update
 
+      # Spree::Core::ControllerHelpers::Auth overrides 
+      # Spree::Api::BaseController's unauthorized method...
+      # Which is not a good thing.
+      # Here's a small hack to shuffle around the method.
+      alias_method :real_unauthorized, :unauthorized
       include Spree::Core::ControllerHelpers::Auth
       include Spree::Core::ControllerHelpers::Order
+      alias_method :unauthorized, :real_unauthorized
 
       respond_to :json
 
@@ -15,6 +21,7 @@ module Spree
       end
 
       def update
+        authorize! :update, @order, params[:order_token]
         respond_with(@order, :default_template => 'spree/api/orders/show') and return if @order.state == "complete"
 
         if object_params && object_params[:user_id].present?

data/app/controllers/spree/api/orders_controller.rb

@@ -17,12 +17,17 @@ module Spree
       end
 
       def create
+        nested_params[:line_items_attributes] = sanitize_line_items(nested_params[:line_items_attributes])
         @order = Order.build_from_api(current_api_user, nested_params)
         respond_with(order, :default_template => :show, :status => 201)
       end
 
       def update
         authorize! :update, Order
+        # Parsing line items through as an update_attributes call in the API will result in
+        # many line items for the same variant_id being created. We must be smarter about this,
+        # hence the use of the update_line_items method, defined within order_decorator.rb.
+        nested_params[:line_items_attributes] = sanitize_line_items(nested_params[:line_items_attributes])
         if order.update_attributes(nested_params)
           order.update!
           respond_with(order, :default_template => :show)
@@ -45,7 +50,20 @@ module Spree
       private
 
       def nested_params
-        map_nested_attributes_keys Order, params[:order] || {}
+        @nested_params ||= map_nested_attributes_keys(Order, params[:order] || {})
+      end
+
+      def sanitize_line_items(line_item_attributes)
+        return {} if line_item_attributes.blank?
+        line_item_attributes = line_item_attributes.map do |id, attributes|
+          # Faux Strong-Parameters code to strip price if user isn't an admin
+          if current_api_user.has_spree_role?("admin")
+            [id, attributes.slice(*Spree::LineItem.attr_accessible[:api])]
+          else
+            [id, attributes.slice(*Spree::LineItem.attr_accessible[:default])]
+          end
+        end
+        line_item_attributes = Hash[line_item_attributes].delete_if { |k,v| v.empty? }
       end
 
       def order

data/app/controllers/spree/api/products_controller.rb

@@ -20,10 +20,14 @@ module Spree
         authorize! :create, Product
         params[:product][:available_on] ||= Time.now
         @product = Product.new(params[:product])
-        if @product.save
-          respond_with(@product, :status => 201, :default_template => :show)
-        else
-          invalid_resource!(@product)
+        begin
+          if @product.save
+            respond_with(@product, :status => 201, :default_template => :show)
+          else
+            invalid_resource!(@product)
+          end
+        rescue ActiveRecord::RecordNotUnique
+          retry
         end
       end
 

data/app/controllers/spree/api/variants_controller.rb

@@ -68,7 +68,7 @@ module Spree
               variants = variants.active
             end
           end
-          variants
+          variants.readonly(false)
         end
     end
   end

data/app/helpers/spree/api/api_helpers.rb

@@ -21,7 +21,7 @@ module Spree
       end
 
       def variant_attributes
-        [:id, :name, :count_on_hand, :sku, :price, :weight, :height, :width, :depth, :is_master, :cost_price, :permalink]
+        [:id, :name, :count_on_hand, :sku, :price, :weight, :height, :width, :depth, :is_master, :cost_price, :permalink, :product_id, :lock_version]
       end
 
       def image_attributes

data/app/models/spree/order_decorator.rb

@@ -1,13 +1,163 @@
 Spree::Order.class_eval do
   def self.build_from_api(user, params)
-    order = create
-    params[:line_items_attributes] ||= []
-    unless params[:line_items_attributes].empty?
-      params[:line_items_attributes].each_key do |k|
-        order.add_variant(Spree::Variant.find(params[:line_items_attributes][k][:variant_id]), params[:line_items_attributes][k][:quantity])
+    begin
+      ensure_country_id_from_api params[:ship_address_attributes]
+      ensure_state_id_from_api params[:ship_address_attributes]
+      ensure_country_id_from_api params[:bill_address_attributes]
+      ensure_state_id_from_api params[:bill_address_attributes]
+
+      order = create!
+
+      order.create_shipments_from_api params.delete(:shipments_attributes) || []
+      order.create_line_items_from_api params.delete(:line_items_attributes) || {}
+      order.create_adjustments_from_api params.delete(:adjustments_attributes) || []
+      order.create_payments_from_api params.delete(:payments_attributes) || []
+      order.complete_from_api params.delete(:completed_at)
+
+      destroy_automatic_taxes_on_import(order, params)
+      order.update_attributes!(params)
+
+      order.reload
+    rescue Exception => e
+      order.destroy if order && order.persisted?
+      raise e.message
+    end
+  end
+
+  def self.destroy_automatic_taxes_on_import(order, params)
+    if params.delete :import
+      order.adjustments.tax.destroy_all
+    end
+  end
+
+  def complete_from_api(completed_at)
+    if completed_at
+      self.completed_at = completed_at
+      self.state = 'complete'
+    end
+  end
+
+  def create_shipments_from_api(shipments_hash)
+    shipments_hash.each do |s|
+      begin
+        shipment = shipments.build
+        shipment.tracking = s[:tracking]
+
+        inventory_units = s[:inventory_units] || []
+        inventory_units.each do |iu|
+          self.class.ensure_variant_id_from_api(iu)
+
+          unit = shipment.inventory_units.build
+          unit.order = self
+          unit.variant_id = iu[:variant_id]
+        end
+
+        shipment.shipping_method = Spree::ShippingMethod.find_by_name!(s[:shipping_method])
+        shipment.save!
+
+        shipment.adjustment.locked = true
+        shipment.adjustment.amount = s[:cost].to_f
+        shipment.adjustment.save
+      rescue Exception => e
+        raise "#{e.message} #{s}"
+      end
+    end
+  end
+
+  def create_payments_from_api(payments_hash)
+    payments_hash.each do |p|
+      begin
+        payment = payments.build
+        payment.amount = p[:amount].to_f
+        payment.state = p.fetch(:state, 'completed')
+        payment.payment_method = Spree::PaymentMethod.find_by_name!(p[:payment_method])
+        payment.save!
+      rescue Exception => e
+        raise "#{e.message} #{p}"
       end
     end
+  end
+
+  def create_line_items_from_api(line_items_hash)
+    line_items_hash.each_key do |k|
+      begin
+        line_item = line_items_hash[k]
+        self.class.ensure_variant_id_from_api(line_item)
+
+        item  = self.add_variant(Spree::Variant.find(line_item[:variant_id]), line_item[:quantity])
 
-    order
+        if line_item.key? :price
+          item.price = line_item[:price]
+          item.save!
+        end
+      rescue Exception => e
+        raise "#{e.message} #{line_item}"
+      end
+    end
+  end
+
+  def create_adjustments_from_api(adjustments)
+    adjustments.each do |a|
+      begin
+        adjustment = self.adjustments.build(:amount => a['amount'].to_f,
+                                            :label => a['label'])
+        adjustment.locked = true
+        adjustment.save!
+      rescue Exception => e
+        raise "#{e.message} #{a}"
+      end
+    end
+  end
+
+  def self.ensure_variant_id_from_api(hash)
+    begin
+      unless hash[:variant_id].present?
+        hash[:variant_id] = Spree::Variant.active.find_by_sku!(hash[:sku]).id
+        hash.delete(:sku)
+      end
+    rescue Exception => e
+      raise "#{e.message} #{hash}"
+    end
+  end
+
+  def self.ensure_country_id_from_api(address)
+    return if address.nil? or address[:country_id].present? or address[:country].nil?
+
+    begin
+      search = {}
+      if name = address[:country]['name']
+        search[:name] = name
+      elsif iso_name = address[:country]['iso_name']
+        search[:iso_name] = iso_name.upcase
+      elsif iso = address[:country]['iso']
+        search[:iso] = iso.upcase
+      elsif iso3 = address[:country]['iso3']
+        search[:iso3] = iso3.upcase
+      end
+
+      address.delete(:country)
+      address[:country_id] = Spree::Country.where(search).first!.id
+
+    rescue Exception => e
+      raise "#{e.message} #{search}"
+    end
+  end
+
+  def self.ensure_state_id_from_api(address)
+    return if address.nil? or address[:state_id].present? or address[:state].nil?
+
+    begin
+      search = {}
+      if name = address[:state]['name']
+        search[:name] = name
+      elsif abbr = address[:state]['abbr']
+        search[:abbr] = abbr.upcase
+      end
+
+      address.delete(:state)
+      address[:state_id] = Spree::State.where(search).first!.id
+    rescue Exception => e
+      raise "#{e.message} #{search}"
+    end
   end
 end

data/app/overrides/api_key_spree_layout.rb

@@ -2,5 +2,6 @@ Deface::Override.new(:virtual_path => "spree/layouts/spree_application",
                      :name => "api_key_spree_layout",
                      :insert_bottom => "body",
                      :partial => "spree/api/key",
-                     :disabled => false)
+                     :disabled => false,
+                     :original => "eb4b04993e8e4d1c20a7c3d974dfed20b59aec4c")
 

data/app/views/spree/api/variants/variant.v1.rabl

@@ -1 +1,5 @@
 attributes *variant_attributes
+node(:options_text) { |v| v.options_text }
+child :option_values => :option_values do
+  attributes *option_value_attributes
+end

data/lib/spree/api/testing_support/setup.rb

@@ -9,19 +9,6 @@ module Spree
             user
           end
         end
-
-        # Default kaminari's pagination to a certain range
-        # Means that you don't need to create 25 objects to test pagination
-        def default_per_page(count)
-          before do
-            @current_default_per_page = Kaminari.config.default_per_page
-            Kaminari.config.default_per_page = 1
-          end
-
-          after do
-            Kaminari.config.default_per_page = @current_default_per_page
-          end
-        end
       end
     end
   end

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

@@ -56,7 +56,7 @@ module Spree
         order.email = nil # email is necessary to transition from cart to address
         order.save!
 
-        api_put :update, :id => order.to_param
+        api_put :update, :id => order.to_param, :order_token => order.token
 
         json_response['error'].should =~ /could not be transitioned/
         response.status.should == 422
@@ -65,13 +65,13 @@ module Spree
       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
+        api_put :update, :id => order.to_param, :order_token => order.token
         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
+        api_put :update, :id => order.to_param, :order_token => order.token
         json_response['error'].should =~ /could not be transitioned/
         response.status.should == 422
       end
@@ -89,7 +89,7 @@ module Spree
           :country_id => @country.id
         }
         api_put :update,
-                :id => order.to_param,
+                :id => order.to_param, :order_token => order.token,
                 :order => { :bill_address_attributes => billing_address, :ship_address_attributes => shipping_address }
 
         json_response['state'].should == 'delivery'
@@ -100,7 +100,8 @@ 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 => { :shipping_method_id => @shipping_method.id }
+        api_put :update, :id => order.to_param, :order_token => order.token,
+                         :order => { :shipping_method_id => @shipping_method.id }
 
         json_response['shipments'][0]['shipping_method']['name'].should == @shipping_method.name
         json_response['state'].should == 'payment'
@@ -109,7 +110,8 @@ 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 => { :payments_attributes => [{ :payment_method_id => @payment_method.id }] }
+        api_put :update, :id => order.to_param, :order_token => order.token,
+                         :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
@@ -118,30 +120,35 @@ 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
+        api_put :update, :id => order.to_param, :order_token => order.token
         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
+        api_put :update, :id => order.to_param, :order_token => order.token
         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 => { :user_id => user.id }
+        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
       end
 
       it "can assign an email to the order" do
-        api_put :update, :id => order.to_param, :order => { :email => "guest@spreecommerce.com" }
+        api_put :update, :id => order.to_param, :order_token => order.token, :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!
+      end
     end
   end
 end

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

@@ -71,6 +71,25 @@ 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
@@ -87,55 +106,67 @@ module Spree
       end
 
       let(:address_params) { { :country_id => Country.first.id, :state_id => State.first.id } }
-      let(:billing_address) { { :firstname => "Tiago", :lastname => "Motta", :address1 => "Av Paulista", 
+      let(:billing_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_address) { { :firstname => "Tiago", :lastname => "Motta", :address1 => "Av Paulista", 
+      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 add line items" do
-        api_put :update, :id => order.to_param, :order => { :line_items => [{:variant_id => create(:variant).id, :quantity => 2}] }
+      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
+              }
+            }
+          }
 
         response.status.should == 200
         json_response['item_total'].to_f.should_not == order.item_total.to_f
       end
-      
+
       it "can add billing address" do
         order.bill_address.should be_nil
-        
+
         api_put :update, :id => order.to_param, :order => { :bill_address_attributes => billing_address }
-        
+
         order.reload.bill_address.should_not be_nil
       end
-      
+
       it "receives error message if trying to add billing address with errors" do
         order.bill_address.should be_nil
         billing_address[:firstname] = ""
-        
+
         api_put :update, :id => order.to_param, :order => { :bill_address_attributes => billing_address }
-        
+
         json_response['error'].should_not be_nil
         json_response['errors'].should_not be_nil
         json_response['errors']['bill_address.firstname'].first.should eq "can't be blank"
       end
-      
+
       it "can add shipping address" do
         order.ship_address.should be_nil
-        
+
         api_put :update, :id => order.to_param, :order => { :ship_address_attributes => shipping_address }
-        
+
         order.reload.ship_address.should_not be_nil
       end
-      
+
       it "receives error message if trying to add shipping address with errors" do
         order.ship_address.should be_nil
         shipping_address[:firstname] = ""
-        
+
         api_put :update, :id => order.to_param, :order => { :ship_address_attributes => shipping_address }
-        
+
         json_response['error'].should_not be_nil
         json_response['errors'].should_not be_nil
         json_response['errors']['ship_address.firstname'].first.should eq "can't be blank"
@@ -151,15 +182,15 @@ module Spree
           response.status.should == 200
           order.reload.line_items.should be_empty
         end
-        
+
         it "can list its line items with images" do
           order.line_items.first.variant.images.create!(:attachment => image("thinking-cat.jpg"))
-          
+
           api_get :show, :id => order.to_param
-          
+
           json_response['line_items'].first['variant'].should have_attributes([:images])
         end
-        
+
         it "lists variants product id" do
           api_get :show, :id => order.to_param
 

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

@@ -28,11 +28,10 @@ module Spree
       end
 
       context "pagination" do
-        default_per_page(1)
 
         it "can select the next page of products" do
           second_product = create(:product)
-          api_get :index, :page => 2
+          api_get :index, :page => 2, :per_page => 1
           json_response["products"].first.should have_attributes(attributes)
           json_response["total_count"].should == 2
           json_response["current_page"].should == 2

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

@@ -14,7 +14,7 @@ module Spree
     let!(:attributes) { [:id, :name, :count_on_hand,
                          :sku, :price, :weight, :height,
                          :width, :depth, :is_master, :cost_price,
-                         :permalink] }
+                         :permalink, :product_id, :lock_version] }
 
     before do
       stub_authentication!
@@ -51,7 +51,7 @@ module Spree
                                                  :option_type_name,
                                                  :option_type_id])
     end
-    
+
     it "variants returned contain images data" do
       variant.images.create!(:attachment => image("thinking-cat.jpg"))
 
@@ -78,11 +78,9 @@ module Spree
     end
 
     context "pagination" do
-      default_per_page(1)
-
       it "can select the next page of variants" do
         second_variant = create(:variant)
-        api_get :index, :page => 2
+        api_get :index, :page => 2, :per_page => 1
         json_response["variants"].first.should have_attributes(attributes)
         json_response["total_count"].should == 3
         json_response["current_page"].should == 2
@@ -99,13 +97,13 @@ module Spree
                                                  :option_type_name,
                                                  :option_type_id])
     end
-    
+
     it "can see a single variant with images" do
       variant.images.create!(:attachment => image("thinking-cat.jpg"))
-      
+
       api_get :show, :id => variant.to_param
-      
-      json_response.should have_attributes(attributes + [:images])      
+
+      json_response.should have_attributes(attributes + [:images])
       option_values = json_response["option_values"]
       option_values.first.should have_attributes([:name,
                                                  :presentation,
@@ -170,6 +168,18 @@ module Spree
         response.status.should == 204
         lambda { variant.reload }.should raise_error(ActiveRecord::RecordNotFound)
       end
+
+      context "without product" do
+        sign_in_as_admin!
+        let(:resource_scoping) { { :product_id => variant.product.to_param } }
+
+        it "will not raise an ActiveRecord::ReadOnlyRecord exception" do
+          api_put :update, :id => variant.to_param, :variant => { :sku => "12345", :on_hand => 5 }
+          response.status.should_not eql 422
+          json_response["exception"].should_not eql "ActiveRecord::ReadOnlyRecord"
+        end
+      end
+
     end
 
 

data/spec/models/spree/order_spec.rb

@@ -2,17 +2,311 @@ require 'spec_helper'
 
 module Spree
   describe Order do
-    let(:user) { stub_model(LegacyUser) }
+    let!(:country) { FactoryGirl.create(:country) }
+    let!(:state) { country.states.first || FactoryGirl.create(:state, :country => country) }
+    let(:user) { create(:user) }
+    let(:product) { Spree::Product.create!(:name => 'Test', :sku => 'TEST-1', :price => 33.22) }
+    let(:sku) { product.master.sku }
+    let(:variant) { product.master }
+    let(:variant_id) { product.master.id }
+    let(:line_items) {{ "0" => { :variant_id => variant.id, :quantity => 5 }}}
+    let(:shipping_method) { create(:shipping_method) }
+    let(:payment_method) { create(:payment_method) }
+    let(:ship_address) {{
+       :address1 => '123 Testable Way',
+       :firstname => 'Fox',
+       :lastname => 'Mulder',
+       :city => 'Washington',
+       :country_id => country.id,
+       :state_id => state.id,
+       :zipcode => '666',
+       :phone => '666-666-6666'
+    }}
 
-    it 'can build an order from API parameters' do
-      product = Spree::Product.create!(:name => 'Test', :sku => 'TEST-1', :price => 33.22)
-      variant_id = product.master.id
-      order = Order.build_from_api(user, { :line_items_attributes => { "0" => { :variant_id => variant_id, :quantity => 5 }}})
+    it 'can import an order number' do
+      params = { number: '123-456-789' }
+      order = Order.build_from_api(user, params)
+      order.number.should eq '123-456-789'
+    end
+
+    it 'optionally add completed at' do
+      params = {:email => 'test@test.com',
+                :completed_at => Time.now,
+                :line_items_attributes => line_items }
+
+      order = Order.build_from_api(user, params)
+      order.should be_completed
+      order.state.should eq 'complete'
+    end
+
+    it "assigns order[email] over user email to order" do
+      params = { email: 'wooowww@test.com' }
+      order = Order.build_from_api(user, params)
+      expect(order.email).to eq params[:email]
+    end
+
+    context "build order with line items" do
+      let(:attributes) do
+        { :variant_id => variant.id, :quantity => 5, :price => 33.77 }
+      end
+
+      it 'can build an order from API with just line items' do
+        params = { :line_items_attributes => { "0" => attributes } }
+        Order.should_receive(:ensure_variant_id_from_api)
+        order = Order.build_from_api(user, params)
+
+        order.user.should == nil
+        line_item = order.line_items.first
+
+        expect(line_item.quantity).to eq attributes[:quantity]
+        expect(line_item.variant_id).to eq attributes[:variant_id]
+        expect(line_item.price).to eq attributes[:price]
+      end
+    end
+
+    it 'uses line item price if present' do
+      line_items['0'][:price] = 12.00
+      params = { :line_items_attributes => line_items }
+
+      order = Order.build_from_api(user, params)
+
+      line_item = order.line_items.first
+      line_item.price.to_f.should == 12.00
+    end
+
+    it 'handles line_item building exceptions' do
+      line_items['0'][:variant_id] = 'XXX'
+      params = { :line_items_attributes => line_items }
+
+      expect {
+        order = Order.build_from_api(user, params)
+      }.to raise_error /XXX/
+    end
+
+    it 'can build an order from API with variant sku' do
+      params = { :line_items_attributes => {
+                   "0" => { :sku => sku, :quantity => 5 } }}
+
+      order = Order.build_from_api(user, params)
 
-      order.user.should == nil
       line_item = order.line_items.first
-      line_item.quantity.should == 5
       line_item.variant_id.should == variant_id
+      line_item.quantity.should == 5
+    end
+
+    it 'handles exceptions when sku is not found' do
+      params = { :line_items_attributes => {
+                   "0" => { :sku => 'XXX', :quantity => 5 } }}
+      expect {
+        order = Order.build_from_api(user, params)
+      }.to raise_error /XXX/
+    end
+
+    it 'can build an order from API shipping address' do
+      params = { :ship_address_attributes => ship_address,
+                 :line_items_attributes => line_items }
+
+      order = Order.build_from_api(user, params)
+      order.ship_address.address1.should eq '123 Testable Way'
+    end
+
+    it 'can build an order from API with country attributes' do
+      ship_address.delete(:country_id)
+      ship_address[:country] = { 'iso' => 'US' }
+      params = { :ship_address_attributes => ship_address,
+                 :line_items_attributes => line_items }
+
+      order = Order.build_from_api(user, params)
+      order.ship_address.country.iso.should eq 'US'
+    end
+
+    it 'handles country lookup exceptions' do
+      ship_address.delete(:country_id)
+      ship_address[:country] = { 'iso' => 'XXX' }
+      params = { :ship_address_attributes => ship_address,
+                 :line_items_attributes => line_items }
+
+      expect {
+        order = Order.build_from_api(user, params)
+      }.to raise_error /XXX/
+    end
+
+    it 'can build an order from API with state attributes' do
+      ship_address.delete(:state_id)
+      ship_address[:state] = { 'name' => 'Alabama' }
+      params = { :ship_address_attributes => ship_address,
+                 :line_items_attributes => line_items }
+
+      order = Order.build_from_api(user, params)
+      order.ship_address.state.name.should eq 'Alabama'
+    end
+
+    it 'handles state lookup exceptions' do
+      ship_address.delete(:state_id)
+      ship_address[:state] = { 'name' => 'XXX' }
+      params = { :ship_address_attributes => ship_address,
+                 :line_items_attributes => line_items }
+
+      expect {
+        order = Order.build_from_api(user, params)
+      }.to raise_error /XXX/
+    end
+
+    context 'variant not deleted' do
+      it 'ensures variant id from api' do
+        hash = { sku: variant.sku }
+        Order.ensure_variant_id_from_api(hash)
+        expect(hash[:variant_id]).to eq variant.id
+      end
+    end
+
+    context 'variant was deleted' do
+      it 'raise error as variant shouldnt be found' do
+        variant.product.delete
+        hash = { sku: variant.sku }
+        expect {
+          Order.ensure_variant_id_from_api(hash)
+        }.to raise_error
+      end
+    end
+
+    it 'ensures_country_id for country fields' do
+      [:name, :iso, :iso_name, :iso3].each do |field|
+        address = { :country => { field => country.send(field) }}
+        Order.ensure_country_id_from_api(address)
+        address[:country_id].should eq country.id
+      end
+    end
+
+    it "raises with proper message when cant find country" do
+      address = { :country => { "name" => "NoNoCountry" } }
+      expect {
+        Order.ensure_country_id_from_api(address)
+      }.to raise_error /NoNoCountry/
+    end
+
+    it 'ensures_state_id for state fields' do
+      [:name, :abbr].each do |field|
+        address = { :state => { field => state.send(field) }}
+        Order.ensure_state_id_from_api(address)
+        address[:state_id].should eq state.id
+      end
+    end
+
+    it "raises with proper message when cant find state" do
+      address = { :state => { "name" => "NoNoState" } }
+      expect {
+        Order.ensure_state_id_from_api(address)
+      }.to raise_error /NoNoState/
+    end
+
+    context "shippments" do
+      let(:params) do
+        { :shipments_attributes => [
+            { :tracking => '123456789',
+              :cost => '4.99',
+              :shipping_method => shipping_method.name,
+              :inventory_units => [{ :sku => sku }]
+            }
+        ] }
+      end
+
+      it 'ensures variant exists and is not deleted' do
+        Order.should_receive(:ensure_variant_id_from_api)
+        order = Order.build_from_api(user, params)
+      end
+
+      it 'builds them properly' do
+        order = Order.build_from_api(user, params)
+
+        shipment = order.shipments.first
+        shipment.inventory_units.first.variant_id.should eq product.master.id
+        shipment.tracking.should eq '123456789'
+        shipment.adjustment.amount.should eq 4.99
+        shipment.adjustment.should be_locked
+      end
+    end
+
+    it 'handles shipment building exceptions' do
+      params = { :shipments_attributes => [{ :tracking => '123456789',
+                                             :cost => '4.99',
+                                             :shipping_method => 'XXX',
+                                             :inventory_units => [{ :sku => sku }]
+                                           }] }
+      expect {
+        order = Order.build_from_api(user, params)
+      }.to raise_error /XXX/
+    end
+
+    it 'adds adjustments' do
+      params = { :adjustments_attributes => [
+          { "label" => "Shipping Discount", "amount" => "-4.99" },
+          { "label" => "Promotion Discount", "amount" => "-3.00" }] }
+
+      order = Order.build_from_api(user, params)
+      order.adjustments.all?(&:locked).should be_true
+      order.adjustments.first.label.should eq 'Shipping Discount'
+      order.adjustments.first.amount.should eq -4.99
+    end
+
+    it 'handles adjustment building exceptions' do
+      params = { :adjustments_attributes => [
+          { "amount" => "XXX" },
+          { "label" => "Promotion Discount", "amount" => "-3.00" }] }
+
+      expect {
+        order = Order.build_from_api(user, params)
+      }.to raise_error /XXX/
+    end
+
+    it 'builds a payment' do
+      params = { :payments_attributes => [{ :amount => '4.99',
+                                            :payment_method => payment_method.name }] }
+      order = Order.build_from_api(user, params)
+      order.payments.first.amount.should eq 4.99
+    end
+
+    it 'handles payment building exceptions' do
+      params = { :payments_attributes => [{ :amount => '4.99',
+                                            :payment_method => 'XXX' }] }
+      expect {
+        order = Order.build_from_api(user, params)
+      }.to raise_error /XXX/
+    end
+
+    context "raises error" do
+      it "clears out order from db" do
+        params = { :payments_attributes => [{ payment_method: "XXX" }] }
+        count = Order.count
+
+        expect { order = Order.build_from_api(user, params) }.to raise_error
+        expect(Order.count).to eq count
+      end
+    end
+
+    context "import param and tax adjustments" do
+      let!(:tax_rate) { create(:tax_rate, amount: 0.05, calculator: Calculator::DefaultTax.create) }
+      let(:other_variant) { create(:variant) }
+
+      let(:line_item_attributes) do
+        line_items.merge({ "1" => { :variant_id => other_variant.id, :quantity => 5 }})
+      end
+
+      before { Zone.stub default_tax: tax_rate.zone }
+
+      it "doesnt create any tax ajustments when importing order" do
+        params = { import: true, line_items_attributes: line_item_attributes }
+        expect {
+          Order.build_from_api(user, params)
+        }.not_to change { Adjustment.count }
+      end
+
+      it "does create tax adjustments if not importing order" do
+        params = { import: false, line_items_attributes: line_item_attributes }
+        expect {
+          Order.build_from_api(user, params)
+        }.to change { Adjustment.count }
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_api
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.3.4
 platform: ruby
 authors:
 - Ryan Bigg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-13 00:00:00.000000000 Z
+date: 2013-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.3.3
+        version: 1.3.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.3.3
+        version: 1.3.4
 - !ruby/object:Gem::Dependency
   name: versioncake
   requirement: !ruby/object:Gem::Requirement
@@ -198,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.1.0
 signing_key: 
 specification_version: 4
 summary: Spree's API