spree_api 1.3.5 → 2.0.0.rc1

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Spree
+  describe Api::StockItemsController do
+    render_views
+
+    let!(:stock_location) { create(:stock_location_with_items) }
+    let!(:stock_item) { stock_location.stock_items.order(:id).first }
+    let!(:attributes) { [:id, :count_on_hand, :backorderable,
+                         :stock_location_id, :variant_id] }
+
+    before do
+      stub_authentication!
+    end
+
+    it 'gets list of stock items' do
+      api_get :index, stock_location_id: stock_location.to_param
+      json_response['stock_items'].first.should have_attributes(attributes)
+      json_response['stock_items'].first['variant']['sku'].should eq 'ABC'
+    end
+
+    it 'requires a stock_location_id to be passed as a parameter' do
+      api_get :index
+      json_response['error'].should =~ /stock_location_id parameter must be provided/
+      response.status.should == 422
+    end
+
+    it 'can control the page size through a parameter' do
+      api_get :index, stock_location_id: stock_location.to_param, per_page: 1
+      json_response['count'].should == 1
+      json_response['current_page'].should == 1
+    end
+
+    it 'can query the results through a paramter' do
+      stock_item.update_column(:count_on_hand, 30)
+      api_get :index, stock_location_id: stock_location.to_param, q: { count_on_hand_eq: '30' }
+      json_response['count'].should == 1
+      json_response['stock_items'].first['count_on_hand'].should eq 30
+    end
+
+    it 'gets a stock item' do
+      api_get :show, stock_location_id: stock_location.to_param, id: stock_item.to_param
+      json_response.should have_attributes(attributes)
+      json_response['count_on_hand'].should eq stock_item.count_on_hand
+    end
+
+    context 'as an admin' do
+      sign_in_as_admin!
+
+      it 'can create a new stock item' do
+        variant = create(:variant)
+        variant.stock_items.delete_all
+        params = {
+          stock_location_id: stock_location.to_param,
+          stock_item: {
+            variant_id: variant.id,
+            count_on_hand: '20'
+          }
+        }
+
+        api_post :create, params
+        response.status.should == 201
+        json_response.should have_attributes(attributes)
+      end
+
+      it 'can update a stock item to add new inventory' do
+        stock_item.count_on_hand.should == 10
+        params = {
+          id: stock_item.to_param,
+          stock_item: {
+            count_on_hand: 40,
+          }
+        }
+
+        api_put :update, params
+        response.status.should == 200
+        json_response['count_on_hand'].should eq 50
+      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)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+module Spree
+  describe Api::StockLocationsController do
+    render_views
+
+    let!(:stock_location) { create(:stock_location) }
+    let!(:attributes) { [:id, :name, :address1, :address2, :city, :state_id, :state_name, :country_id, :zipcode, :phone, :active] }
+
+    before do
+      stub_authentication!
+    end
+
+    it "gets list of stock locations" do
+      api_get :index
+      json_response['stock_locations'].first.should have_attributes(attributes)
+    end
+
+    it "includes the country" do
+      api_get :index
+      json_response['stock_locations'].first['country'].should_not be_nil
+    end
+
+    it "includes the state" do
+      api_get :index
+      json_response['stock_locations'].first['state'].should_not be_nil
+    end
+
+    it 'can control the page size through a parameter' do
+      create(:stock_location)
+      api_get :index, per_page: 1
+      json_response['count'].should == 1
+      json_response['current_page'].should == 1
+      json_response['pages'].should == 2
+    end
+
+    it 'can query the results through a paramter' do
+      expected_result = create(:stock_location, name: 'South America')
+      api_get :index, q: { name_cont: 'south' }
+      json_response['count'].should == 1
+      json_response['stock_locations'].first['name'].should eq expected_result.name
+    end
+
+    it "gets a stock location" do
+      api_get :show, id: stock_location.to_param
+      json_response.should have_attributes(attributes)
+      json_response['name'].should eq stock_location.name
+    end
+
+    context "as an admin" do
+      sign_in_as_admin!
+
+      it "can create a new stock location" do
+        params = {
+          stock_location: {
+            name: "North Pole",
+            active: true
+          }
+        }
+
+        api_post :create, params
+        response.status.should == 201
+        json_response.should have_attributes(attributes)
+      end
+
+      it "can update a stock location" do
+        params = {
+          id: stock_location.to_param,
+          stock_location: {
+            name: "South Pole"
+          }
+        }
+
+        api_put :update, params
+        response.status.should == 200
+        json_response['name'].should eq 'South Pole'
+      end
+
+      it "can delete a stock location" do
+        api_delete :destroy, id: stock_location.to_param
+        response.status.should == 204
+        lambda { stock_location.reload }.should raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module Spree
+  describe Api::StockMovementsController do
+    render_views
+
+    let!(:stock_location) { create(:stock_location_with_items) }
+    let!(:stock_item) { stock_location.stock_items.order(:id).first }
+    let!(:stock_movement) { create(:stock_movement, stock_item: stock_item) }
+    let!(:attributes) { [:id, :quantity, :stock_item_id] }
+
+    before do
+      stub_authentication!
+    end
+
+    it 'gets list of stock movements' do
+      api_get :index, stock_location_id: stock_location.to_param
+      json_response['stock_movements'].first.should have_attributes(attributes)
+      json_response['stock_movements'].first['stock_item']['count_on_hand'].should eq 11
+    end
+
+    it 'requires a stock_location_id to be passed as a parameter' do
+      api_get :index
+      json_response['error'].should =~ /stock_location_id parameter must be provided/
+      response.status.should == 422
+    end
+
+    it 'can control the page size through a parameter' do
+      create(:stock_movement, stock_item: stock_item)
+      api_get :index, stock_location_id: stock_location.to_param, per_page: 1
+      json_response['count'].should == 1
+      json_response['current_page'].should == 1
+      json_response['pages'].should == 2
+    end
+
+    it 'can query the results through a paramter' do
+      expected_result = create(:stock_movement, :received, quantity: 10, stock_item: stock_item)
+      api_get :index, stock_location_id: stock_location.to_param, q: { quantity_eq: '10' }
+      json_response['count'].should == 1
+    end
+
+    it 'gets a stock movement' do
+      api_get :show, stock_location_id: stock_location.to_param, id: stock_movement.to_param
+      json_response.should have_attributes(attributes)
+      json_response['stock_item_id'].should eq stock_movement.stock_item_id
+    end
+
+    context 'as an admin' do
+      sign_in_as_admin!
+
+      it 'can create a new stock movement' do
+        params = {
+          stock_location_id: stock_location.to_param,
+          stock_movement: {
+            stock_item_id: stock_item.to_param
+          }
+        }
+
+        api_post :create, params
+        response.status.should == 201
+        json_response.should have_attributes(attributes)
+      end
+
+      it 'can delete a stock movement' do
+        api_delete :destroy, id: stock_movement.to_param
+        response.status.should == 204
+        lambda { stock_movement.reload }.should raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+  end
+end
+

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

@@ -59,6 +59,13 @@ module Spree
         children.first.key?('taxons').should be_true
       end
 
+      it "gets the jstree-friendly version of a taxonomy" do
+        api_get :jstree, :id => taxonomy.id
+        json_response["data"].should eq(taxonomy.root.name)
+        json_response["attr"].should eq({ "id" => taxonomy.root.id, "name" => taxonomy.root.name})
+        json_response["state"].should eq("closed")
+      end
+
       it "can learn how to create a new taxonomy" do
         api_get :new
         json_response["attributes"].should == attributes.map(&:to_s)

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

@@ -7,7 +7,7 @@ module Spree
     let(:taxonomy) { create(:taxonomy) }
     let(:taxon) { create(:taxon, :name => "Ruby", :taxonomy => taxonomy) }
     let(:taxon2) { create(:taxon, :name => "Rails", :taxonomy => taxonomy) }
-    let(:attributes) { ["id", "name", "permalink", "position", "parent_id", "taxonomy_id"] }
+    let(:attributes) { ["id", "name", "pretty_name", "permalink", "position", "parent_id", "taxonomy_id"] }
 
     before do
       stub_authentication!
@@ -17,7 +17,7 @@ module Spree
     end
 
     context "as a normal user" do
-      it "gets all taxons" do
+      it "gets all taxons for a taxonomy" do
         api_get :index, :taxonomy_id => taxonomy.id
 
         json_response.first['name'].should eq taxon.name
@@ -27,6 +27,23 @@ module Spree
         children.first['taxons'].count.should eq 1
       end
 
+      it "gets all taxons" do
+        api_get :index
+
+        json_response.first['name'].should eq taxonomy.root.name
+        children = json_response.first['taxons']
+        children.count.should eq 1
+        children.first['name'].should eq taxon.name
+        children.first['taxons'].count.should eq 1
+      end
+
+      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"
+      end
+
       it "gets a single taxon" do
         api_get :show, :id => taxon.id, :taxonomy_id => taxonomy.id
 
@@ -34,6 +51,16 @@ module Spree
         json_response['taxons'].count.should eq 1
       end
 
+      it "gets all taxons in JSTree form" do
+        api_get :jstree, :taxonomy_id => taxonomy.id, :id => taxon.id
+        response = json_response.first
+        response["data"].should eq(taxon2.name)
+        response["attr"].should eq({ "name" => taxon2.name, "id" => taxon2.id})
+        response["state"].should eq("closed")
+      end
+
+
+
       it "can learn how to create a new taxon" do
         api_get :new, :taxonomy_id => taxonomy.id
         json_response["attributes"].should == attributes.map(&:to_s)

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

@@ -6,7 +6,7 @@ module Spree
     render_views
 
     let!(:product) { create(:product) }
-    let(:attributes) { [:id, :name, :description, :price, :available_on, :permalink, :count_on_hand, :meta_description, :meta_keywords, :taxon_ids] }
+    let(:attributes) { [:id, :name, :description, :price, :available_on, :permalink, :meta_description, :meta_keywords, :taxon_ids] }
 
     context "without authentication" do
       before { Spree::Api::Config[:requires_authentication] = false }

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

@@ -11,10 +11,9 @@ module Spree
       variant.option_values << create(:option_value)
       variant
     end
-    let!(:attributes) { [:id, :name, :count_on_hand,
-                         :sku, :price, :weight, :height,
+    let!(:attributes) { [:id, :name, :sku, :price, :weight, :height,
                          :width, :depth, :is_master, :cost_price,
-                         :permalink, :product_id, :lock_version] }
+                         :permalink] }
 
     before do
       stub_authentication!
@@ -78,9 +77,11 @@ 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, :per_page => 1
+        api_get :index, :page => 2
         json_response["variants"].first.should have_attributes(attributes)
         json_response["total_count"].should == 3
         json_response["current_page"].should == 2
@@ -168,18 +169,6 @@ 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,338 +2,17 @@ require 'spec_helper'
 
 module Spree
   describe Order do
-    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'
-    }}
+    let(:user) { stub_model(LegacyUser) }
+    let(:product) { create :product }
 
-    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
-
-      it "ensures quantity values are converted to integer" do
-        params = {
-          :line_items_attributes => {
-            "0" => { :variant_id => variant.id, :quantity => "5" },
-            "1" => { :variant_id => variant.id, :quantity => "5" }
-          }
-        }
-
-        order = Order.build_from_api(user, params)
-        expect(order.line_items.first.quantity).to eq 10
-      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)
+    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 }}})
 
+      order.user.should == nil
       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)
-
-      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' => state.name }
-      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
-
-    context "state passed is not associated with country" do
-      let(:params) do
-        params = { :ship_address_attributes => ship_address,
-                   :line_items_attributes => line_items }
-      end
-
-      let(:other_state) { create(:state, name: "Uhuhuh", country: create(:country)) }
-
-      before do
-        country.states.destroy_all
-
-        ship_address.delete(:state_id)
-        ship_address[:state] = { 'name' => other_state.name }
-      end
-
-      it 'sets states name instead of state id' do
-        order = Order.build_from_api(user, params)
-        expect(order.ship_address.state_name).to eq other_state.name
-      end
-    end
-
-    it 'sets state name if state record not found' do
-      country.states.destroy_all
-
-      ship_address.delete(:state_id)
-      ship_address[:state] = { 'name' => 'XXX' }
-      params = { :ship_address_attributes => ship_address,
-                 :line_items_attributes => line_items }
-
-      order = Order.build_from_api(user, params)
-      expect(order.ship_address.state_name).to eq '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 = { country_id: country.id, :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.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
+      line_item.variant_id.should == variant_id
     end
   end
 end