spree_api 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f5519b716277f189e3ca709d60342a6644f63e6
-  data.tar.gz: 5d8d83310106f05dee2dd8ed5a0f01aa66d1f6f1
+  metadata.gz: 0c5fb9fd878e6c935137a8f09d6b4cffa35f78db
+  data.tar.gz: aef11d5c34c3cfa8f55c78fa0f987e493220618c
 SHA512:
-  metadata.gz: 5f850cf66f2e7a8bd57940b7961f1e740be4a0d0aeabe87ffe5e45f0a3641c7a7c81ffa72301517b5ca07ac5761a3071cb09dabbe69652593656ad382a487367
-  data.tar.gz: 03ac9cf7f05c894ebab107a30c6f0d6613835e8c55a2407e4b62f30e2b257fbdcf38cd97842f72a8a10f9032068e252f4c10f8e1b024e852036acdc82621eefa
+  metadata.gz: 4ccb7dc808ccfe6a0badbcca88f2fee1c7f40bff832051b851384be324fbe1c9d97c128b9447d18c6d836a1f77b921fa8dab75c19be1ad73a48c68ea6f2e3652
+  data.tar.gz: 560ebb4f8b5019b23c3686e8f92131b5ec4a692923e6173e0c93b6740568527b2466b039787c84503c07908caf008a9aee2971cb7434514cb87df920eaed3e37

data/CHANGELOG.md

@@ -1,6 +1,4 @@
-## Spree 2.0.5 (unreleased)
-
-## Spree 2.0.4
+## Spree 2.0.x ##
 
 * PUT requests to Checkouts API endpoints now require authorization to alter an order.
 
@@ -29,3 +27,17 @@
 * Attributes other than "quantity" and "variant_id" will be added to a line item when creating along with an order. #3404
 
     *Alex Marles & Ryan Bigg* 
+
+* Taxon attributes from `/api/taxons` are now returned within `taxons` subkey. Before:
+
+```json
+[{ name: 'Ruby' ... }]
+```
+
+Now:
+
+```json
+{ taxons: [{ name: 'Ruby' }]}
+```
+
+    * Ryan Bigg

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

@@ -1,16 +1,17 @@
 module Spree
   module Api
     class AddressesController < Spree::Api::BaseController
+      before_filter :find_order
 
       def show
-        @address = Address.find(params[:id])
-        authorize! :read, @address
+        authorize! :read, @order, params[:order_token]
+        find_address
         respond_with(@address)
       end
 
       def update
-        @address = Address.find(params[:id])
-        authorize! :read, @address
+        authorize! :update, @order, params[:order_token]
+        find_address
 
         if @address.update_attributes(params[:address])
           respond_with(@address, :default_template => :show)
@@ -18,6 +19,22 @@ module Spree
           invalid_resource!(@address)
         end
       end
+
+      private
+
+        def find_order
+          @order = Spree::Order.find_by_number!(params[:order_id])
+        end
+
+        def find_address
+          @address = if @order.bill_address_id == params[:id].to_i
+            @order.bill_address
+          elsif @order.ship_address_id == params[:id].to_i
+            @order.ship_address
+          else
+            raise CanCan::AccessDenied
+          end
+        end
     end
   end
 end

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

@@ -1,8 +1,9 @@
 module Spree
   module Api
     class CheckoutsController < Spree::Api::BaseController
-      before_filter :load_order, :only => [:update, :next]
-      before_filter :associate_user, :only => :update
+
+      before_filter :load_order,     only: [:show, :update, :next, :advance]
+      before_filter :associate_user, only: :update
 
       include Spree::Core::ControllerHelpers::Auth
       include Spree::Core::ControllerHelpers::Order
@@ -13,7 +14,25 @@ module Spree
 
       def create
         @order = Order.build_from_api(current_api_user, nested_params)
-        respond_with(@order, :default_template => 'spree/api/orders/show', :status => 201)
+        respond_with(@order, default_template: 'spree/api/orders/show', status: 201)
+      end
+
+      def next
+        authorize! :update, @order, params[:order_token]
+        @order.next!
+        respond_with(@order, default_template: 'spree/api/orders/show', status: 200)
+      rescue StateMachine::InvalidTransition
+        respond_with(@order, default_template: 'spree/api/orders/could_not_transition', status: 422)
+      end
+
+      def advance
+        authorize! :update, @order, params[:order_token]
+        while @order.next; end
+        respond_with(@order, default_template: 'spree/api/orders/show', status: 200)
+      end
+
+      def show
+        respond_with(@order, default_template: 'spree/api/orders/show', status: 200)
       end
 
       def update
@@ -23,8 +42,6 @@ module Spree
         line_items = order_params.delete("line_items_attributes")
         if @order.update_attributes(order_params)
           @order.update_line_items(line_items)
-          # TODO: Replace with better code when we switch to strong_parameters
-          # Also remove above user_id stripping
           if current_api_user.has_spree_role?("admin") && user_id.present?
             @order.associate_user!(Spree.user_class.find(user_id))
           end

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

@@ -23,7 +23,13 @@ module Spree
 
       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.
+        line_items_params = params[:order].delete("line_items")
         if order.update_attributes(nested_params)
+          order.update_line_items(line_items_params)
+          order.line_items.reload
           order.update!
           respond_with(order, :default_template => :show)
         else
@@ -37,7 +43,7 @@ module Spree
       end
 
       def empty
-        order.line_items.destroy_all
+        order.empty!
         order.update!
         render :text => nil, :status => 200
       end

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

@@ -41,7 +41,10 @@ module Spree
           params[:stock_item].delete(:count_on_hand)
         end
 
-        if @stock_item.adjust_count_on_hand(count_on_hand)
+        updated = params[:stock_item][:force] ? @stock_item.set_count_on_hand(count_on_hand)
+                                              : @stock_item.adjust_count_on_hand(count_on_hand)
+
+        if updated
           respond_with(@stock_item, status: 200, default_template: :show)
         else
           invalid_resource!(@stock_item)

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

@@ -8,11 +8,13 @@ module Spree
           @taxons = taxonomy.root.children
         else
           if params[:ids]
-            @taxons = Taxon.where(:id => params[:ids].split(","))
+            @taxons = Taxon.accessible_by(current_ability, :read).where(:id => params[:ids].split(","))
           else
-            @taxons = Taxon.ransack(params[:q]).result
+            @taxons = Taxon.accessible_by(current_ability, :read).order(:taxonomy_id, :lft).ransack(params[:q]).result
           end
         end
+
+        @taxons = @taxons.page(params[:page]).per(params[:per_page])
         respond_with(@taxons)
       end
 

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

@@ -6,7 +6,7 @@ module Spree
       before_filter :product
 
       def index
-        @variants = scope.includes(:option_values).ransack(params[:q]).result.
+        @variants = scope.includes(:option_values, :stock_items, :product, :images, :prices).ransack(params[:q]).result.
           page(params[:page]).per(params[:per_page])
         respond_with(@variants)
       end

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

@@ -71,6 +71,10 @@ module Spree
         [:id, :number, :state, :amount, :order_id, :reason, :created_at, :updated_at]
       end
 
+      def address_attributes
+        [:id, :firstname, :lastname, :full_name, :address1, :address2, :city, :zipcode, :phone, :company, :alternative_phone, :country_id, :state_id, :state_name]
+      end
+
       def country_attributes
         [:id, :iso_name, :iso, :iso3, :name, :numcode]
       end

data/app/models/spree/order_decorator.rb

@@ -1,20 +1,155 @@
 Spree::Order.class_eval do
   def self.build_from_api(user, params)
-    line_items = params.delete(:line_items_attributes) || []
+    completed_at = params.delete(:completed_at)
+    line_items = params.delete(:line_items_attributes) || {}
+    shipments = params.delete(:shipments_attributes) || []
+    payments = params.delete(:payments_attributes) || []
+    adjustments = params.delete(:adjustments_attributes) || []
 
-    order = create(params)
+    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!(params)
     order.associate_user!(user)
 
-    unless line_items.empty?
-      line_items.each_key do |k|
-        line_item = line_items[k]
+    order.create_shipments_from_api(shipments)
+    order.create_line_items_from_api(line_items)
+    order.create_adjustments_from_api(adjustments)
+    order.create_payments_from_api(payments)
+    order.complete_from_api(completed_at)
+
+    order.save!
+    order.reload
+  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.save!
+
+        shipping_method = Spree::ShippingMethod.find_by_name!(s[:shipping_method])
+        shipment.shipping_rates.create!(:shipping_method => shipping_method,
+                                        :cost => s[:cost])
+      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)
+
         extra_params = line_item.except(:variant_id, :quantity)
-        line_item = order.contents.add(Spree::Variant.find(line_item[:variant_id]), line_item[:quantity])
+        line_item = self.contents.add(Spree::Variant.find(line_item[:variant_id]), line_item[:quantity])
         line_item.update_attributes(extra_params) unless extra_params.empty?
+      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.save!
+        adjustment.finalize!
+      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?
 
-    order
+    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
 
   def update_line_items(line_item_params)
@@ -22,5 +157,6 @@ Spree::Order.class_eval do
     line_item_params.each do |id, attributes|
       self.line_items.find(id).update_attributes!(attributes)
     end
+    self.ensure_updated_shipments
   end
 end

data/app/views/spree/api/addresses/show.v1.rabl

@@ -1,8 +1,6 @@
 object @address
-attributes :id, :firstname, :lastname, :address1, :address2,
-           :city, :zipcode, :phone,
-           :company, :alternative_phone, :country_id, :state_id,
-           :state_name
+attributes *address_attributes
+
 child(:country) do |address|
   attributes *country_attributes
 end

data/app/views/spree/api/taxons/index.v1.rabl

@@ -1,4 +1,10 @@
-collection @taxons
-attributes *taxon_attributes
-
-extends "spree/api/taxons/taxons"
+object false
+node(:count) { @taxons.count }
+node(:total_count) { @taxons.total_count }
+node(:current_page) { params[:page] ? params[:page].to_i : 1 }
+node(:per_page) { params[:per_page] || Kaminari.config.default_per_page }
+node(:pages) { @taxons.num_pages }
+child(@taxons) do
+  attributes *taxon_attributes
+  extends "spree/api/taxons/taxons"
+end

data/config/routes.rb

@@ -18,6 +18,7 @@ Spree::Core::Engine.routes.draw do
     resources :checkouts do
       member do
         put :next
+        put :advance
       end
     end
 
@@ -28,6 +29,8 @@ Spree::Core::Engine.routes.draw do
     end
 
     resources :orders do
+      resources :addresses, :only => [:show, :update]
+
       resources :return_authorizations do
         member do
           put :add
@@ -64,7 +67,6 @@ Spree::Core::Engine.routes.draw do
     resources :zones
     resources :countries, :only => [:index, :show]
     resources :states,    :only => [:index, :show]
-    resources :addresses, :only => [:show, :update]
 
     resources :taxonomies do
       member do

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

@@ -7,26 +7,27 @@ module Spree
     before do
       stub_authentication!
       @address = create(:address)
+      @order = create(:order, :bill_address => @address)
     end
 
     context "with their own address" do
       before do
-        Address.any_instance.stub :user => current_api_user
+        Order.any_instance.stub :user => current_api_user
       end
 
       it "gets an address" do
-        api_get :show, :id => @address.id
+        api_get :show, :id => @address.id, :order_id => @order.number
         json_response['address1'].should eq @address.address1
       end
 
       it "updates an address" do
-        api_put :update, :id => @address.id,
+        api_put :update, :id => @address.id, :order_id => @order.number,
                          :address => { :address1 => "123 Test Lane" }
         json_response['address1'].should eq '123 Test Lane'
       end
       
       it "receives the errors object if address is invalid" do
-        api_put :update, :id => @address.id,
+        api_put :update, :id => @address.id, :order_id => @order.number,
                          :address => { :address1 => "" }
                          
         json_response['error'].should_not be_nil
@@ -35,18 +36,19 @@ module Spree
       end
     end
 
-    context "on somebody else's address" do
+    context "on an address that does not belong to this order" do
       before do
-        Address.any_instance.stub :user => stub_model(Spree::LegacyUser)
+        @order.bill_address_id = nil
+        @order.ship_address = nil
       end
 
       it "cannot retreive address information" do
-        api_get :show, :id => @address.id
+        api_get :show, :id => @address.id, :order_id => @order.number
         assert_unauthorized!
       end
 
       it "cannot update address information" do
-        api_get :update, :id => @address.id
+        api_get :update, :id => @address.id, :order_id => @order.number
         assert_unauthorized!
       end
     end

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

@@ -66,7 +66,6 @@ module Spree
         api_put :update, :id => order.to_param, :order_token => order.token,
                          :order => { :line_items_attributes => { line_item.id => { :quantity => 1 } } }
         response.status.should == 200
-        order.reload.state.should eq "address"
       end
 
       it "can take line_items as a parameter" do
@@ -74,7 +73,6 @@ module Spree
         api_put :update, :id => order.to_param, :order_token => order.token,
                          :order => { :line_items => { line_item.id => { :quantity => 1 } } }
         response.status.should == 200
-        order.reload.state.should eq "address"
       end
 
       it "will return an error if the order cannot transition" do
@@ -234,5 +232,18 @@ module Spree
         json_response["errors"]["base"].should include(Spree.t(:no_pending_payments))
       end
     end
+
+    context "PUT 'advance'" do
+      let!(:order) { create(:order_with_line_items) }
+      it 'continues to advance advances an order while it can move forward' do
+        Spree::Order.any_instance.should_receive(:next).exactly(3).times.and_return(true, true, false)
+        api_put :advance, :id => order.to_param, :order_token => order.token
+      end
+      it 'returns the order' do
+        api_put :advance, :id => order.to_param, :order_token => order.token
+        json_response['id'].should == order.id
+      end
+
+    end
   end
 end

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

@@ -79,7 +79,7 @@ module Spree
       # Regression test for #3404
       it "can specify additional parameters for a line item" do
         variant = create(:variant)
-        Order.should_receive(:create).and_return(order = Spree::Order.new)
+        Order.should_receive(:create!).and_return(order = Spree::Order.new)
         order.stub(:associate_user!)
         order.stub_chain(:contents, :add).and_return(line_item = double('LineItem'))
         line_item.should_receive(:update_attributes).with("special" => true)
@@ -96,7 +96,7 @@ module Spree
       # Regression test for #3404
       it "does not update line item needlessly" do
         variant = create(:variant)
-        Order.should_receive(:create).and_return(order = Spree::Order.new)
+        Order.should_receive(:create!).and_return(order = Spree::Order.new)
         order.stub(:associate_user!)
         order.stub_chain(:contents, :add).and_return(line_item = double('LineItem'))
         line_item.should_not_receive(:update_attributes)
@@ -156,7 +156,8 @@ module Spree
       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}] }
+        api_put :update, :id => order.to_param, :order => {
+          :line_items_attributes => [{:variant_id => create(:variant).id, :quantity => 2}] }
 
         response.status.should == 200
         json_response['item_total'].to_f.should_not == order.item_total.to_f
@@ -165,6 +166,18 @@ module Spree
         json_response['line_items'].last['quantity'].should == 2
       end
 
+      it "updates quantities of existing line items" do
+        api_put :update, :id => order.to_param, :order => {
+          :line_items => {
+            line_item.id => { :quantity => 10 }
+          }
+        }
+
+        response.status.should == 200
+        json_response['line_items'].count.should == 1
+        json_response['line_items'].first['quantity'].should == 10
+      end
+
       it "can add billing address" do
         api_put :update, :id => order.to_param, :order => { :bill_address_attributes => billing_address }
 
@@ -201,6 +214,20 @@ module Spree
         json_response['errors']['ship_address.firstname'].first.should eq "can't be blank"
       end
 
+      context "order has shipments" do
+        before { order.create_proposed_shipments }
+
+        it "clears out all existing shipments on line item udpate" do
+          previous_shipments = order.shipments
+          api_put :update, :id => order.to_param, :order => {
+            :line_items => {
+              line_item.id => { :quantity => 10 }
+            }
+          }
+          expect(order.reload.shipments).to be_empty
+        end
+      end
+
       context "with a line item" do
         before do
           create(:line_item, :order => order)

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

@@ -49,7 +49,9 @@ module Spree
 
       it 'can create a new stock item' do
         variant = create(:variant)
-        variant.stock_items.delete_all
+        # Creating a variant also creates stock items.
+        # We don't want any to exist (as they would conflict with what we're about to create)
+        StockItem.delete_all
         params = {
           stock_location_id: stock_location.to_param,
           stock_item: {
@@ -77,10 +79,26 @@ module Spree
         json_response['count_on_hand'].should eq 50
       end
 
+      it 'can set a stock item to modify the current inventory' do
+        stock_item.count_on_hand.should == 10
+
+        params = {
+          id: stock_item.to_param,
+          stock_item: {
+            count_on_hand: 40,
+            force: true,
+          }
+        }
+
+        api_put :update, params
+        response.status.should == 200
+        json_response['count_on_hand'].should eq 40
+      end
+
       it 'can delete a stock item' do
         api_delete :destroy, id: stock_item.to_param
         response.status.should == 204
-        lambda { stock_item.reload }.should raise_error(ActiveRecord::RecordNotFound)
+        lambda { Spree::StockItem.find(stock_item.id) }.should raise_error(ActiveRecord::RecordNotFound)
       end
     end
   end

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

@@ -20,18 +20,30 @@ module Spree
       it "gets all taxons for a taxonomy" do
         api_get :index, :taxonomy_id => taxonomy.id
 
-        json_response.first['name'].should eq taxon.name
-        children = json_response.first['taxons']
+        json_response['taxons'].first['name'].should eq taxon.name
+        children = json_response['taxons'].first['taxons']
         children.count.should eq 1
         children.first['name'].should eq taxon2.name
         children.first['taxons'].count.should eq 1
       end
 
+      it "paginates through taxons" do
+        new_taxon = create(:taxon, :name => "Go", :taxonomy => taxonomy)
+        taxonomy.root.children << new_taxon
+        expect(taxonomy.root.children.count).to eql(2)
+        api_get :index, :taxonomy_id => taxonomy.id, :page => 1, :per_page => 1
+        expect(json_response["count"]).to eql(1)
+        expect(json_response["total_count"]).to eql(2)
+        expect(json_response["current_page"]).to eql(1)
+        expect(json_response["per_page"]).to eql(1)
+        expect(json_response["pages"]).to eql(2)
+      end
+
       it "gets all taxons" do
         api_get :index
 
-        json_response.first['name'].should eq taxonomy.root.name
-        children = json_response.first['taxons']
+        json_response['taxons'].first['name'].should eq taxonomy.root.name
+        children = json_response['taxons'].first['taxons']
         children.count.should eq 1
         children.first['name'].should eq taxon.name
         children.first['taxons'].count.should eq 1
@@ -40,8 +52,8 @@ module Spree
       it "can search for a single taxon" do
         api_get :index, :q => { :name_cont => "Ruby" }
 
-        json_response.count.should == 1
-        json_response.first['name'].should eq "Ruby"
+        json_response['taxons'].count.should == 1
+        json_response['taxons'].first['name'].should eq "Ruby"
       end
 
       it "gets a single taxon" do

data/spec/models/spree/order_spec.rb

@@ -2,17 +2,247 @@ require 'spec_helper'
 
 module Spree
   describe Order do
-    let(:user) { stub_model(LegacyUser) }
-    let(:product) { create :product }
+    let!(:country) { FactoryGirl.create(:country) }
+    let!(:state) { country.states.first || FactoryGirl.create(:state, :country => country) }
+    let!(:stock_location) { FactoryGirl.create(:stock_location) }
 
-    it 'can build an order from API parameters' do
-      variant_id = product.master.id
-      order = Order.build_from_api(user, { :line_items_attributes => { "0" => { :variant_id => variant_id, :quantity => 5 }}})
+    let(:user) { stub_model(LegacyUser, :email => 'fox@mudler.com') }
+    let(:shipping_method) { create(:shipping_method) }
+    let(:payment_method) { create(:payment_method) }
+    let(:product) { product = Spree::Product.create(:name => 'Test',
+                                           :sku => 'TEST-1',
+                                           :price => 33.22)
+                    product.shipping_category = FactoryGirl.create(:shipping_category)
+                    product.save
+                    product }
+    let(:variant) { variant = product.master
+                    variant.stock_items.each { |si| si.update_attribute(:count_on_hand, 10) }
+                    variant }
+    let(:sku) { variant.sku }
+    let(:variant_id) { variant.id }
 
+    let(:line_items) {{ "0" => { :variant_id => variant.id, :quantity => 5 }}}
+    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 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 'can build an order from API with just line items' do
+      params = { :line_items_attributes => line_items }
+
+      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
       line_item.quantity.should == 5
       line_item.variant_id.should == variant_id
     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)
+
+      line_item = order.line_items.first
+      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.destroy
+        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 '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
+
+    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.shipping_rates.first.cost.should eq 4.99
+      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?(&:finalized?).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
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_api
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.5
 platform: ruby
 authors:
 - Ryan Bigg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-05 00:00:00.000000000 Z
+date: 2013-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.4
+        version: 2.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.4
+        version: 2.0.5
 - !ruby/object:Gem::Dependency
   name: rabl
   requirement: !ruby/object:Gem::Requirement
@@ -244,7 +244,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