solidus_api 2.10.5 → 2.11.0

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

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  PermittedAttributes.module_eval do
-    mattr_writer :line_item_attributes
-  end
-
-  unless PermittedAttributes.line_item_attributes.include? :options
-    PermittedAttributes.line_item_attributes << { options: [:some_option] }
-  end
-
-  describe Api::LineItemsController, type: :request do
-    let!(:order) { create(:order_with_line_items, line_items_count: 1) }
-
-    let(:product) { create(:product) }
-    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
-      get spree.new_api_order_line_item_path(order)
-      expect(json_response["attributes"]).to eq(["quantity", "price", "variant_id"])
-      required_attributes = json_response["required_attributes"]
-      expect(required_attributes).to include("quantity", "variant_id")
-    end
-
-    context "authenticating with a token" do
-      it "can add a new line item to an existing order" do
-        post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 }, order_token: order.guest_token }
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["variant"]["name"]).not_to be_blank
-      end
-
-      it "can add a new line item to an existing order with token in header" do
-        post spree.api_order_line_items_path(order),
-          params: { line_item: { variant_id: product.master.to_param, quantity: 1 } },
-          headers: { 'X-Spree-Order-Token' => order.guest_token }
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["variant"]["name"]).not_to be_blank
-      end
-    end
-
-    context "as the order owner" do
-      before do
-        allow_any_instance_of(Order).to receive_messages user: current_api_user
-      end
-
-      context "dealing with a completed order" do
-        let!(:order) { create(:completed_order_with_totals) }
-
-        it "can't add a new line item" do
-          post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 } }
-          assert_unauthorized!
-        end
-
-        it "can't update a line item" do
-          line_item = order.line_items.first
-          put spree.api_order_line_item_path(order, line_item), params: { line_item: { quantity: 10 } }
-          assert_unauthorized!
-        end
-
-        it "can't delete a line item" do
-          line_item = order.line_items.first
-          delete spree.api_order_line_item_path(order, line_item)
-          assert_unauthorized!
-        end
-      end
-
-      it "can add a new line item to an existing order" do
-        post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 } }
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["variant"]["name"]).not_to be_blank
-      end
-
-      it "can add a new line item to an existing order with options" do
-        without_partial_double_verification do
-          expect_any_instance_of(LineItem).to receive(:some_option=).with("foobar")
-        end
-        post spree.api_order_line_items_path(order),
-                 params: {
-                                    line_item: {
-                              variant_id: product.master.to_param,
-                              quantity: 1,
-                              options: { some_option: "foobar" }
-                            }
-        }
-        expect(response.status).to eq(201)
-      end
-
-      it "default quantity to 1 if none is given" do
-        post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param } }
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response[:quantity]).to eq 1
-      end
-
-      it "increases a line item's quantity if it exists already" do
-        order.line_items.create(variant_id: product.master.id, quantity: 10)
-        post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 } }
-        expect(response.status).to eq(201)
-        order.reload
-        expect(order.line_items.count).to eq(2) # 1 original due to factory, + 1 in this test
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["quantity"]).to eq(11)
-      end
-
-      it "can update a line item on the order" do
-        line_item = order.line_items.first
-        put spree.api_order_line_item_path(order, line_item), params: { line_item: { quantity: 101 } }
-        expect(response.status).to eq(200)
-        order.reload
-        expect(order.total).to eq(1010) # 10 original due to factory, + 1000 in this test
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response["quantity"]).to eq(101)
-      end
-
-      it "can update a line item's options on the order" do
-        without_partial_double_verification do
-          expect_any_instance_of(LineItem).to receive(:some_option=).with("foobar")
-        end
-        line_item = order.line_items.first
-        put spree.api_order_line_item_path(order, line_item),
-                params: {
-                  line_item: { quantity: 1, options: { some_option: "foobar" } }
-                }
-        expect(response.status).to eq(200)
-      end
-
-      it "can delete a line item on the order" do
-        line_item = order.line_items.first
-        delete spree.api_order_line_item_path(order, line_item)
-        expect(response.status).to eq(204)
-        order.reload
-        expect(order.line_items.count).to eq(0) # 1 original due to factory, - 1 in this test
-        expect { line_item.reload }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-
-      context "order contents changed after shipments were created" do
-        let!(:store) { create(:store) }
-        let!(:order) { Order.create(store: store) }
-        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
-          post spree.api_order_line_items_path(order), params: { 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
-          put spree.api_order_line_item_path(order, line_item), params: { line_item: { quantity: 1000 } }
-          expect(order.reload.shipments).to be_empty
-        end
-
-        it "clear out shipments on delete" do
-          expect(order.reload.shipments).not_to be_empty
-          delete spree.api_order_line_item_path(order, line_item)
-          expect(order.reload.shipments).to be_empty
-        end
-
-        context "order is completed" do
-          before do
-            allow(order).to receive_messages completed?: true
-            allow(Order).to receive_message_chain :includes, find_by!: order
-          end
-
-          it "doesn't destroy shipments or restart checkout flow" do
-            expect(order.reload.shipments).not_to be_empty
-            post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 } }
-            expect(order.reload.shipments).not_to be_empty
-          end
-        end
-      end
-    end
-
-    context "as just another user" do
-      before do
-        user = create(:user)
-        allow(Spree.user_class).to receive(:find_by).
-                                     and_return(user)
-      end
-
-      it "cannot add a new line item to the order" do
-        post spree.api_order_line_items_path(order), params: { line_item: { variant_id: product.master.to_param, quantity: 1 } }
-        assert_unauthorized!
-      end
-
-      it "cannot update a line item on the order" do
-        line_item = order.line_items.first
-        put spree.api_order_line_item_path(order, line_item), params: { line_item: { quantity: 1000 } }
-        assert_unauthorized!
-        expect(line_item.reload.quantity).not_to eq(1000)
-      end
-
-      it "cannot delete a line item on the order" do
-        line_item = order.line_items.first
-        delete spree.api_order_line_item_path(order, line_item)
-        assert_unauthorized!
-        expect { line_item.reload }.not_to raise_error
-      end
-    end
-  end
-end

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

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::OptionTypesController, type: :request do
-    let(:attributes) { [:id, :name, :position, :presentation] }
-    let!(:option_value) { create(:option_value) }
-    let!(:option_type) { option_value.option_type }
-
-    before do
-      stub_authentication!
-    end
-
-    def check_option_values(option_values)
-      expect(option_values.count).to eq(1)
-      expect(option_values.first).to have_attributes([:id, :name, :presentation,
-                                                      :option_type_name, :option_type_id])
-    end
-
-    it "can list all option types" do
-      get spree.api_option_types_path
-      expect(json_response.count).to eq(1)
-      expect(json_response.first).to have_attributes(attributes)
-
-      check_option_values(json_response.first["option_values"])
-    end
-
-    it "can search for an option type" do
-      create(:option_type, name: "buzz")
-      get spree.api_option_types_path, params: { q: { name_cont: option_type.name } }
-      expect(json_response.count).to eq(1)
-      expect(json_response.first).to have_attributes(attributes)
-    end
-
-    it "can retrieve a list of specific option types" do
-      option_type_one = create(:option_type)
-      create(:option_type)
-      get spree.api_option_types_path, params: { ids: "#{option_type.id},#{option_type_one.id}" }
-      expect(json_response.count).to eq(2)
-
-      check_option_values(json_response.first["option_values"])
-    end
-
-    it "can list a single option type" do
-      get spree.api_option_type_path(option_type)
-      expect(json_response).to have_attributes(attributes)
-      check_option_values(json_response["option_values"])
-    end
-
-    it "cannot create a new option type" do
-      post spree.api_option_types_path, params: {
-        option_type: {
-          name: "Option Type",
-          presentation: "Option Type"
-        }
-      }
-      assert_unauthorized!
-    end
-
-    it "cannot alter an option type" do
-      original_name = option_type.name
-      put spree.api_option_type_path(option_type), params: {
-        option_type: {
-          name: "Option Type"
-        }
-      }
-      assert_not_found!
-      expect(option_type.reload.name).to eq(original_name)
-    end
-
-    it "cannot delete an option type" do
-      delete spree.api_option_type_path(option_type)
-      assert_not_found!
-      expect { option_type.reload }.not_to raise_error
-    end
-
-    context "as an admin" do
-      sign_in_as_admin!
-
-      it "can create an option type" do
-        post spree.api_option_types_path, params: {
-          option_type: {
-            name: "Option Type",
-            presentation: "Option Type"
-          }
-        }
-        expect(json_response).to have_attributes(attributes)
-        expect(response.status).to eq(201)
-      end
-
-      it "cannot create an option type with invalid attributes" do
-        post spree.api_option_types_path, params: { option_type: {} }
-        expect(response.status).to eq(422)
-      end
-
-      it "can update an option type" do
-        put spree.api_option_type_path(option_type.id), params: { option_type: { name: "Option Type" } }
-        expect(response.status).to eq(200)
-
-        option_type.reload
-        expect(option_type.name).to eq("Option Type")
-      end
-
-      it "cannot update an option type with invalid attributes" do
-        put spree.api_option_type_path(option_type.id), params: { option_type: { name: "" } }
-        expect(response.status).to eq(422)
-      end
-
-      it "can delete an option type" do
-        delete spree.api_option_type_path(option_type.id)
-        expect(response.status).to eq(204)
-      end
-    end
-  end
-end

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

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::OptionValuesController, type: :request do
-    let(:attributes) { [:id, :name, :presentation, :option_type_name, :option_type_name] }
-    let!(:option_value) { create(:option_value) }
-    let!(:option_type) { option_value.option_type }
-
-    before do
-      stub_authentication!
-    end
-
-    def check_option_values(option_values)
-      expect(option_values.count).to eq(1)
-      expect(option_values.first).to have_attributes([:id, :name, :presentation,
-                                                      :option_type_name, :option_type_id])
-    end
-
-    context "without any option type scoping" do
-      before do
-        # Create another option value with a brand new option type
-        create(:option_value, option_type: create(:option_type))
-      end
-
-      it "can retrieve a list of all option values" do
-        get spree.api_option_values_path
-        expect(json_response.count).to eq(2)
-        expect(json_response.first).to have_attributes(attributes)
-      end
-    end
-
-    context "for a particular option type" do
-      let(:resource_scoping) { { option_type_id: option_type.id } }
-
-      it "can list all option values" do
-        get spree.api_option_values_path
-        expect(json_response.count).to eq(1)
-        expect(json_response.first).to have_attributes(attributes)
-      end
-
-      it "can search for an option type" do
-        create(:option_value, name: "buzz")
-        get spree.api_option_values_path, params: { q: { name_cont: option_value.name } }
-        expect(json_response.count).to eq(1)
-        expect(json_response.first).to have_attributes(attributes)
-      end
-
-      it "can retrieve a list of option types" do
-        option_value_one = create(:option_value, option_type: option_type)
-        create(:option_value, option_type: option_type)
-        get spree.api_option_values_path, params: { ids: [option_value.id, option_value_one.id] }
-        expect(json_response.count).to eq(2)
-      end
-
-      it "can list a single option value" do
-        get spree.api_option_value_path(option_value.id)
-        expect(json_response).to have_attributes(attributes)
-      end
-
-      it "cannot create a new option value" do
-        post spree.api_option_type_option_values_path(option_type), params: {
-                          option_value: {
-                                            name: "Option Value",
-                                            presentation: "Option Value"
-                                          }
-        }
-        assert_unauthorized!
-      end
-
-      it "cannot alter an option value" do
-        original_name = option_type.name
-        put spree.api_option_value_path(option_value.id), params: {
-                            id: option_type.id,
-                            option_value: {
-                              name: "Option Value"
-                            }
-                          }
-        assert_not_found!
-        expect(option_type.reload.name).to eq(original_name)
-      end
-
-      it "cannot delete an option value" do
-        delete spree.api_option_value_path(option_value)
-        assert_not_found!
-        expect { option_type.reload }.not_to raise_error
-      end
-
-      context "as an admin" do
-        sign_in_as_admin!
-
-        it "can create an option value" do
-          post spree.api_option_type_option_values_path(option_type), params: {
-                            option_value: {
-                                              name: "Option Value",
-                                              presentation: "Option Value",
-                                            }
-          }
-          expect(json_response).to have_attributes(attributes)
-          expect(response.status).to eq(201)
-        end
-
-        it "cannot create an option type with invalid attributes" do
-          post spree.api_option_type_option_values_path(option_type), params: { option_value: { name: "" } }
-          expect(response.status).to eq(422)
-        end
-
-        it "can update an option value" do
-          put spree.api_option_value_path(option_value.id), params: { option_value: {
-                                name: "Option Value"
-                              } }
-          expect(response.status).to eq(200)
-
-          option_value.reload
-          expect(option_value.name).to eq("Option Value")
-        end
-
-        it "permits the correct attributes" do
-          expect_any_instance_of(Spree::Api::OptionValuesController).to receive(:permitted_option_value_attributes)
-          put spree.api_option_value_path(option_value), params: { option_value: { name: "" } }
-        end
-
-        it "cannot update an option value with invalid attributes" do
-          put spree.api_option_value_path(option_value), params: { option_value: {
-                            name: ""
-                           } }
-          expect(response.status).to eq(422)
-        end
-
-        it "can delete an option value" do
-          delete spree.api_option_value_path(option_value)
-          expect(response.status).to eq(204)
-        end
-      end
-    end
-  end
-end