spree_api 2.0.13 → 2.1.0

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

@@ -9,36 +9,40 @@ module Spree
       @inventory_unit = create(:inventory_unit)
     end
 
-    it "gets an inventory unit" do
-      api_get :show, :id => @inventory_unit.id
-      json_response['state'].should eq @inventory_unit.state
-    end
-
-    it "updates an inventory unit (only shipment is accessable by default)" do
-      api_put :update, :id => @inventory_unit.id,
-                       :inventory_unit => { :shipment => nil }
-      json_response['shipment_id'].should be_nil
-    end
-
-    context 'fires state event' do
-      it 'if supplied with :fire param' do
-        api_put :update, :id => @inventory_unit.id,
-                         :fire => 'ship',
-                         :inventory_unit => { :shipment => nil }
+    context "as an admin" do
+      sign_in_as_admin!
 
-        json_response['state'].should eq 'shipped'
+      it "gets an inventory unit" do
+        api_get :show, :id => @inventory_unit.id
+        json_response['state'].should eq @inventory_unit.state
       end
 
-      it 'and returns exception if cannot fire' do
+      it "updates an inventory unit (only shipment is accessable by default)" do
         api_put :update, :id => @inventory_unit.id,
-                         :fire => 'return'
-        json_response['exception'].should match /cannot transition to return/
+                         :inventory_unit => { :shipment => nil }
+        json_response['shipment_id'].should be_nil
       end
 
-      it 'and returns exception bad state' do
-        api_put :update, :id => @inventory_unit.id,
-                         :fire => 'bad'
-        json_response['exception'].should match /cannot transition to bad/
+      context 'fires state event' do
+        it 'if supplied with :fire param' do
+          api_put :update, :id => @inventory_unit.id,
+                           :fire => 'ship',
+                           :inventory_unit => { :shipment => nil }
+
+          json_response['state'].should eq 'shipped'
+        end
+
+        it 'and returns exception if cannot fire' do
+          api_put :update, :id => @inventory_unit.id,
+                           :fire => 'return'
+          json_response['exception'].should match /cannot transition to return/
+        end
+
+        it 'and returns exception bad state' do
+          api_put :update, :id => @inventory_unit.id,
+                           :fire => 'bad'
+          json_response['exception'].should match /cannot transition to bad/
+        end
       end
     end
   end

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

@@ -7,20 +7,31 @@ module Spree
     let!(:order) { create(:order_with_line_items) }
 
     let(:product) { create(:product) }
-    let(:attributes) { [:id, :quantity, :price, :variant] }
+    let(:attributes) { [:id, :quantity, :price, :variant, :total, :display_amount, :single_display_amount] }
     let(:resource_scoping) { { :order_id => order.to_param } }
 
+    before do
+      stub_authentication!
+    end
+
     it "can learn how to create a new line item" do
-      controller.stub :try_spree_current_user => current_api_user
       api_get :new
       json_response["attributes"].should == ["quantity", "price", "variant_id"]
       required_attributes = json_response["required_attributes"]
       required_attributes.should include("quantity", "variant_id")
     end
 
+    context "authenticating with a token" do
+      it "can add a new line item to an existing order" do
+        api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }, :order_token => order.token
+        response.status.should == 201
+        json_response.should have_attributes(attributes)
+        json_response["variant"]["name"].should_not be_blank
+      end
+    end
+
     context "as the order owner" do
       before do
-        controller.stub :try_spree_current_user => current_api_user
         Order.any_instance.stub :user => current_api_user
       end
 
@@ -31,6 +42,16 @@ module Spree
         json_response["variant"]["name"].should_not be_blank
       end
 
+      it "increases a line item's quantity if it exists already" do
+        order.line_items.create(:variant_id => product.master.id, :quantity => 10)
+        api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }
+        response.status.should == 201
+        order.reload
+        order.line_items.count.should == 6 # 5 original due to factory, + 1 in this test
+        json_response.should have_attributes(attributes)
+        json_response["quantity"].should == 11
+      end
+
       it "can update a line item on the order" do
         line_item = order.line_items.first
         api_put :update, :id => line_item.id, :line_item => { :quantity => 1000 }
@@ -44,33 +65,9 @@ module Spree
         response.status.should == 204
         lambda { line_item.reload }.should raise_error(ActiveRecord::RecordNotFound)
       end
-
-      context "order contents changed after shipments were created" do
-        let!(:order) { Order.create }
-        let!(:line_item) { order.contents.add(product.master) }
-
-        before { order.create_proposed_shipments }
-
-        it "clear out shipments on create" do
-          expect(order.reload.shipments).not_to be_empty
-          api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }
-          expect(order.reload.shipments).to be_empty
-        end
-
-        it "clear out shipments on update" do
-          expect(order.reload.shipments).not_to be_empty
-          api_put :update, :id => line_item.id, :line_item => { :quantity => 1000 }
-          expect(order.reload.shipments).to be_empty
-        end
-      end
     end
 
     context "as just another user" do
-      before do
-        user = create(:user)
-        controller.stub :try_spree_current_user => user
-      end
-
       it "cannot add a new line item to the order" do
         api_post :create, :line_item => { :variant_id => product.master.to_param, :quantity => 1 }
         assert_unauthorized!
@@ -90,5 +87,6 @@ module Spree
         lambda { line_item.reload }.should_not raise_error
       end
     end
+
   end
 end

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

@@ -62,13 +62,13 @@ module Spree
                         :option_type => {
                           :name => "Option Type"
                         }
-      assert_unauthorized!
+      assert_not_found!
       option_type.reload.name.should == original_name
     end
 
     it "cannot delete an option type" do
       api_delete :destroy, :id => option_type.id
-      assert_unauthorized!
+      assert_not_found!
       lambda { option_type.reload }.should_not raise_error
     end
 

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

@@ -73,13 +73,13 @@ module Spree
                           :option_value => {
                             :name => "Option Value"
                           }
-        assert_unauthorized!
+        assert_not_found!
         option_type.reload.name.should == original_name
       end
 
       it "cannot delete an option value" do
         api_delete :destroy, :id => option_type.id
-        assert_unauthorized!
+        assert_not_found!
         lambda { option_type.reload }.should_not raise_error
       end
 

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

@@ -5,15 +5,17 @@ module Spree
     render_views
 
     let!(:order) { create(:order) }
-    let(:attributes) { [:number, :item_total, :total,
+    let(:attributes) { [:number, :item_total, :display_total, :total,
                         :state, :adjustment_total,
                         :user_id, :created_at, :updated_at,
                         :completed_at, :payment_total, :shipment_state,
-                        :payment_state, :email, :special_instructions, :token] }
+                        :payment_state, :email, :special_instructions,
+                        :total_quantity, :display_item_total] }
 
-    let(:variant) { create(:variant) }
 
-    before { stub_authentication! }
+    before do
+      stub_authentication!
+    end
 
     it "cannot view all orders" do
       api_get :index
@@ -29,6 +31,13 @@ module Spree
       json_response["credit_cards"].should be_empty
     end
 
+    it "orders contain the basic checkout steps" do
+      Order.any_instance.stub :user => current_api_user
+      api_get :show, :id => order.to_param
+      response.status.should == 200
+      json_response["checkout_steps"].should == ["address", "delivery", "complete"]
+    end
+
     # Regression test for #1992
     it "can view an order not in a standard state" do
       Order.any_instance.stub :user => current_api_user
@@ -42,6 +51,11 @@ module Spree
       assert_unauthorized!
     end
 
+    it "can view an order if the token is known" do
+      api_get :show, :id => order.to_param, :order_token => order.token
+      response.status.should == 200
+    end
+
     it "cannot cancel an order that doesn't belong to them" do
       order.update_attribute(:completed_at, Time.now)
       order.update_attribute(:shipment_state, "ready")
@@ -54,89 +68,68 @@ module Spree
       assert_unauthorized!
     end
 
-    context "create order" do
-      let(:current_api_user) do
-        user = Spree.user_class.new(:email => "spree@example.com")
-        user.generate_spree_api_key!
-        user
-      end
+    let(:address_params) { { :country_id => Country.first.id, :state_id => State.first.id } }
+    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",
+                               :city => "Sao Paulo", :zipcode => "1234567", :phone => "12345678",
+                               :country_id => Country.first.id, :state_id => State.first.id} }
+    let!(:payment_method) { create(:payment_method) }
+    let(:current_api_user) do
+      user = Spree.user_class.new(:email => "spree@example.com")
+      user.generate_spree_api_key!
+      user
+    end
 
-      it "can create an order" do
-        variant = create(:variant)
-        api_post :create, :order => { :line_items => { "0" => { :variant_id => variant.to_param, :quantity => 5 } } }
-        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
-        json_response["state"].should == "cart"
-        order.user.should == current_api_user
-        order.email == current_api_user.email
-        json_response["user_id"].should == current_api_user.id
-      end
+    it "can create an order" do
+      variant = create(:variant)
+      api_post :create, :order => { :line_items => { "0" => { :variant_id => variant.to_param, :quantity => 5 } } }
+      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
+      json_response["token"].should_not be_blank
+      json_response["state"].should == "cart"
+      order.user.should == current_api_user
+      order.email.should == current_api_user.email
+      json_response["user_id"].should == current_api_user.id
+    end
 
-      context "import" do
-        let(:tax_rate) { create(:tax_rate, amount: 0.05, calculator: Calculator::DefaultTax.create) }
-        let(:other_variant) { create(:variant) }
-
-        # line items come in as an array when importing orders or when
-        # creating both an order an a line item at once
-        let(:order_params) do
-          {
-            :line_items => [
-              { :variant_id => variant.to_param, :quantity => 5 },
-              { :variant_id => other_variant.to_param, :quantity => 5 }
-            ]
+    # 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.stub(:associate_user!)
+      order.stub_chain(:contents, :add).and_return(line_item = double('LineItem'))
+      line_item.should_receive(:update_attributes).with("special" => true)
+
+      controller.stub(permitted_line_item_attributes: [:id, :variant_id, :quantity, :special])
+      api_post :create, :order => { 
+        :line_items => {
+          "0" => {
+            :variant_id => variant.to_param, :quantity => 5, :special => true
           }
-        end
-
-        before do
-          Zone.stub default_tax: tax_rate.zone
-          current_api_user.stub has_spree_role?: true
-        end
-
-        it "sets channel" do
-          api_post :create, :order => { channel: "amazon" }
-          expect(json_response['channel']).to eq "amazon"
-        end
-
-        it "doesnt persist any automatic tax adjustment" do
-          expect {
-            api_post :create, :order => order_params.merge(:import => true)
-          }.not_to change { Adjustment.count }
-          expect(response.status).to eq 201
-        end
-
-        context "provides sku rather than variant id" do
-          let(:order_params) do
-            { :line_items => [{ :sku => variant.sku, :quantity => 1 }] }
-          end
-
-          it "still finds the variant by sku and persist order" do
-            api_post :create, :order => order_params
-            expect(json_response['line_items'].count).to eq 1
-          end
-        end
-      end
+        }
+      }
+      response.status.should == 201
+    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
-            }
+    # 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.stub(:associate_user!)
+      order.stub_chain(:contents, :add).and_return(line_item = double('LineItem'))
+      line_item.should_not_receive(:update_attributes)
+      api_post :create, :order => { 
+        :line_items => {
+          "0" => {
+            :variant_id => variant.to_param, :quantity => 5
           }
         }
-        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
+      }
     end
 
     it "can create an order without any parameters" do
@@ -147,6 +140,8 @@ module Spree
     end
 
     context "working with an order" do
+
+      let(:variant) { create(:variant) }
       let!(:line_item) { order.contents.add(variant, 1) }
       let!(:payment_method) { create(:payment_method) }
 
@@ -173,15 +168,6 @@ module Spree
         address
       end
 
-      let(:address_params) { { :country_id => Country.first.id, :state_id => State.first.id } }
-      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",
-                                 :city => "Sao Paulo", :zipcode => "1234567", :phone => "12345678",
-                                 :country_id => Country.first.id, :state_id => State.first.id} }
-      let!(:payment_method) { create(:payment_method) }
-
       it "updates quantities of existing line items" do
         api_put :update, :id => order.to_param, :order => {
           :line_items => {
@@ -194,18 +180,6 @@ module Spree
         json_response['line_items'].first['quantity'].should == 10
       end
 
-      it "cannot set a price for a line item" do
-        variant = create(:variant)
-        api_put :update, :id => order.to_param, :order => {
-          :line_items_attributes => { order.line_items.first.id =>
-            { :variant_id => variant.id, :quantity => 2, :price => 0.44}
-          }
-        }
-        response.status.should == 200
-        json_response['line_items'].count.should == 1
-        expect(json_response['line_items'].first['price']).to eq(variant.price.to_s)
-      end
-
       it "can add billing address" do
         api_put :update, :id => order.to_param, :order => { :bill_address_attributes => billing_address }
 
@@ -223,7 +197,6 @@ module Spree
       end
 
       it "can add shipping address" do
-        pending "need to figure out how to get shipping methods for an order"
         order.ship_address.should be_nil
 
         api_put :update, :id => order.to_param, :order => { :ship_address_attributes => shipping_address }
@@ -257,15 +230,19 @@ module Spree
       end
 
       context "with a line item" do
-        before do
-          create(:line_item, :order => order)
-          order.reload
+        let(:order_with_line_items) do
+          order = create(:order_with_line_items)
+          create(:adjustment, :adjustable => order)
+          order
         end
 
         it "can empty an order" do
-          api_put :empty, :id => order.to_param
+          order_with_line_items.adjustments.count.should be == 1
+          api_put :empty, :id => order_with_line_items.to_param
           response.status.should == 200
-          order.reload.line_items.should be_empty
+          order_with_line_items.reload
+          order_with_line_items.line_items.should be_empty
+          order_with_line_items.adjustments.should be_empty
         end
 
         it "can list its line items with images" do
@@ -281,6 +258,50 @@ module Spree
 
           json_response['line_items'].first['variant'].should have_attributes([:product_id])
         end
+
+        context "when in delivery" do
+          let!(:shipping_method) do
+            FactoryGirl.create(:shipping_method).tap do |shipping_method|
+              shipping_method.calculator.preferred_amount = 10
+              shipping_method.calculator.save
+            end
+          end
+
+          before do
+            order.ship_address = FactoryGirl.create(:address)
+            order.state = 'delivery'
+            order.save
+          end
+
+          it "returns available shipments for an order" do
+            api_get :show, :id => order.to_param
+            response.status.should == 200
+            json_response["shipments"].should_not be_empty
+            shipment = json_response["shipments"][0]
+            # Test for correct shipping method attributes
+            # Regression test for #3206
+            shipment["shipping_methods"].should_not be_nil
+            json_shipping_method = shipment["shipping_methods"][0]
+            json_shipping_method["id"].should == shipping_method.id
+            json_shipping_method["name"].should == shipping_method.name
+            json_shipping_method["zones"].should_not be_empty
+            json_shipping_method["shipping_categories"].should_not be_empty
+
+            # Test for correct shipping rates attributes
+            # Regression test for #3206
+            shipment["shipping_rates"].should_not be_nil
+            shipping_rate = shipment["shipping_rates"][0]
+            shipping_rate["name"].should == json_shipping_method["name"]
+            shipping_rate["cost"].should == "10.0"
+            shipping_rate["selected"].should be_true
+            shipping_rate["display_cost"].should == "$10.00"
+
+            shipment["stock_location_name"].should_not be_blank
+            manifest_item = shipment["manifest"][0]
+            manifest_item["quantity"].should == 1
+            manifest_item["variant"].should have_attributes([:id, :name, :sku, :price])
+          end
+        end
       end
     end
 
@@ -295,17 +316,6 @@ module Spree
         end
       end
 
-      it "responds with orders updated_at with miliseconds precision" do
-        if ActiveRecord::Base.connection.adapter_name == "Mysql2"
-          pending "MySQL does not support millisecond timestamps."
-        end
-
-        api_get :index
-        milisecond = order.updated_at.strftime("%L")
-        updated_at = json_response["orders"].first["updated_at"]
-        expect(updated_at.split("T").last).to have_content(milisecond)
-      end
-
       context "with two orders" do
         before { create(:order) }
 
@@ -365,3 +375,4 @@ module Spree
     end
   end
 end
+