solidus_api 2.10.5 → 2.11.0

data/script/rails

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
-
-ENGINE_ROOT = File.expand_path('..', __dir__)
-ENGINE_PATH = File.expand_path('../lib/spree/api/engine', __dir__)
-
-require 'rails/all'
-require 'rails/engine/commands'

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

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-class FakesController < Spree::Api::BaseController
-end
-
-describe Spree::Api::BaseController, type: :controller do
-  render_views
-  controller(Spree::Api::BaseController) do
-    rescue_from Spree::Order::InsufficientStock, with: :insufficient_stock_error
-
-    def index
-      render json: { "products" => [] }
-    end
-  end
-
-  before do
-    @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
-      r.draw { get 'index', to: 'spree/api/base#index' }
-    end
-  end
-
-  context "when validating based on an order token" do
-    let!(:order) { create :order }
-
-    context "with a correct order token" do
-      it "succeeds" do
-        get :index, params: { order_token: order.guest_token, order_id: order.number }
-        expect(response.status).to eq(200)
-      end
-
-      it "succeeds with an order_number parameter" do
-        get :index, params: { order_token: order.guest_token, order_number: order.number }
-        expect(response.status).to eq(200)
-      end
-    end
-
-    context "with an incorrect order token" do
-      it "returns unauthorized" do
-        get :index, params: { order_token: "NOT_A_TOKEN", order_id: order.number }
-        expect(response.status).to eq(401)
-      end
-    end
-  end
-
-  context "cannot make a request to the API" do
-    it "without an API key" do
-      get :index
-      expect(json_response).to eq({ "error" => "You must specify an API key." })
-      expect(response.status).to eq(401)
-    end
-
-    it "with an invalid API key" do
-      request.headers["Authorization"] = "Bearer fake_key"
-      get :index, params: {}
-      expect(json_response).to eq({ "error" => "Invalid API key (fake_key) specified." })
-      expect(response.status).to eq(401)
-    end
-
-    it "using an invalid token param" do
-      get :index, params: { token: "fake_key" }
-      expect(json_response).to eq({ "error" => "Invalid API key (fake_key) specified." })
-    end
-  end
-
-  it "lets a subclass override the product associations that are eager-loaded" do
-    expect(controller.respond_to?(:product_includes, true)).to be
-  end
-
-  context 'insufficient stock' do
-    before do
-      expect(subject).to receive(:authenticate_user).and_return(true)
-      expect(subject).to receive(:index).and_raise(Spree::Order::InsufficientStock)
-      get :index, params: { token: "fake_key" }
-    end
-
-    it "should return a 422" do
-      expect(response.status).to eq(422)
-    end
-
-    it "returns an error message" do
-      expect(json_response).to eq(
-        { "errors" => ["Quantity is not available for items in your order"], "type" => "insufficient_stock" }
-      )
-    end
-  end
-
-  context 'lock_order' do
-    let!(:order) { create :order }
-
-    controller(Spree::Api::BaseController) do
-      around_action :lock_order
-
-      def index
-        render json: { "products" => [] }
-      end
-    end
-
-    context 'without an existing lock' do
-      it 'succeeds' do
-        get :index, params: { order_token: order.guest_token, order_id: order.number }
-        expect(response.status).to eq(200)
-      end
-    end
-
-    context 'with an existing lock' do
-      around do |example|
-        Spree::OrderMutex.with_lock!(order) { example.run }
-      end
-
-      it 'returns a 409 conflict' do
-        get :index, params: { order_token: order.guest_token, order_id: order.number }
-        expect(response.status).to eq(409)
-      end
-    end
-  end
-end

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

@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  module Api
-    class WidgetsController < Spree::Api::ResourceController
-      prepend_view_path('spec/test_views')
-
-      def model_class
-        Widget
-      end
-
-      def permitted_widget_attributes
-        [:name]
-      end
-    end
-  end
-
-  describe Api::WidgetsController, type: :controller do
-    render_views
-
-    after(:all) do
-      Rails.application.reload_routes!
-    end
-
-    with_model 'Widget', scope: :all do
-      table do |widget|
-        widget.string :name
-        widget.integer :position
-        widget.timestamps null: false
-      end
-
-      model do
-        acts_as_list
-        validates :name, presence: true
-      end
-    end
-
-    before do
-      Spree::Core::Engine.routes.draw do
-        namespace :api do
-          resources :widgets
-        end
-      end
-    end
-
-    let(:user) { create(:user, :with_api_key) }
-    let(:admin_user) { create(:admin_user, :with_api_key) }
-
-    describe "#index" do
-      let!(:widget) { Widget.create!(name: "a widget") }
-
-      it "returns no widgets" do
-        get :index, params: { token: user.spree_api_key }, as: :json
-        expect(response).to be_successful
-        expect(json_response['widgets']).to be_blank
-      end
-
-      context "it has authorization to read widgets" do
-        it "returns widgets" do
-          get :index, params: { token: admin_user.spree_api_key }, as: :json
-          expect(response).to be_successful
-          expect(json_response['widgets']).to include(
-            hash_including(
-              'name' => 'a widget',
-              'position' => 1
-            )
-          )
-        end
-
-        context "specifying ids" do
-          let!(:widget2) { Widget.create!(name: "a widget") }
-
-          it "returns both widgets from comma separated string" do
-            get :index, params: { ids: [widget.id, widget2.id].join(','), token: admin_user.spree_api_key }, as: :json
-            expect(response).to be_successful
-            expect(json_response['widgets'].size).to eq 2
-          end
-
-          it "returns both widgets from multiple arguments" do
-            get :index, params: { ids: [widget.id, widget2.id], token: admin_user.spree_api_key }, as: :json
-            expect(response).to be_successful
-            expect(json_response['widgets'].size).to eq 2
-          end
-
-          it "returns one requested widgets" do
-            get :index, params: { ids: widget2.id.to_s, token: admin_user.spree_api_key }, as: :json
-            expect(response).to be_successful
-            expect(json_response['widgets'].size).to eq 1
-            expect(json_response['widgets'][0]['id']).to eq widget2.id
-          end
-
-          it "returns no widgets if empty" do
-            get :index, params: { ids: '', token: admin_user.spree_api_key }, as: :json
-            expect(response).to be_successful
-            expect(json_response['widgets']).to be_empty
-          end
-        end
-      end
-    end
-
-    describe "#show" do
-      let(:widget) { Widget.create!(name: "a widget") }
-
-      it "returns not found" do
-        get :show, params: { id: widget.to_param, token: user.spree_api_key }, as: :json
-        assert_not_found!
-      end
-
-      context "it has authorization read widgets" do
-        it "returns widget details" do
-          get :show, params: { id: widget.to_param, token: admin_user.spree_api_key }, as: :json
-          expect(response).to be_successful
-          expect(json_response['name']).to eq 'a widget'
-        end
-      end
-    end
-
-    describe "#new" do
-      it "returns unauthorized" do
-        get :new, params: { token: user.spree_api_key }, as: :json
-        expect(response).to be_unauthorized
-      end
-
-      context "it is allowed to view a new widget" do
-        it "can learn how to create a new widget" do
-          get :new, params: { token: admin_user.spree_api_key }, as: :json
-          expect(response).to be_successful
-          expect(json_response["attributes"]).to eq(['name'])
-        end
-      end
-    end
-
-    describe "#create" do
-      it "returns unauthorized" do
-        expect {
-          post :create, params: { widget: { name: "a widget" }, token: user.spree_api_key }, as: :json
-        }.not_to change(Widget, :count)
-        expect(response).to be_unauthorized
-      end
-
-      context "it is authorized to create widgets" do
-        it "can create a widget" do
-          expect {
-            post :create, params: { widget: { name: "a widget" }, token: admin_user.spree_api_key }, as: :json
-          }.to change(Widget, :count).by(1)
-          expect(response).to be_created
-          expect(json_response['name']).to eq 'a widget'
-          expect(Widget.last.name).to eq 'a widget'
-        end
-      end
-    end
-
-    describe "#update" do
-      let!(:widget) { Widget.create!(name: "a widget") }
-      it "returns unauthorized" do
-        put :update, params: { id: widget.to_param, widget: { name: "another widget" }, token: user.spree_api_key }, as: :json
-        assert_not_found!
-        expect(widget.reload.name).to eq 'a widget'
-      end
-
-      context "it is authorized to update widgets" do
-        it "can update a widget" do
-          put :update, params: { id: widget.to_param, widget: { name: "another widget" }, token: admin_user.spree_api_key }, as: :json
-          expect(response).to be_successful
-          expect(json_response['name']).to eq 'another widget'
-          expect(widget.reload.name).to eq 'another widget'
-        end
-      end
-    end
-
-    describe "#destroy" do
-      let!(:widget) { Widget.create!(name: "a widget") }
-      it "returns unauthorized" do
-        delete :destroy, params: { id: widget.to_param, token: user.spree_api_key }, as: :json
-        assert_not_found!
-        expect { widget.reload }.not_to raise_error
-      end
-
-      context "it is authorized to destroy widgets" do
-        it "can destroy a widget" do
-          delete :destroy, params: { id: widget.to_param, token: admin_user.spree_api_key }, as: :json
-          expect(response.status).to eq 204
-          expect { widget.reload }.to raise_error(ActiveRecord::RecordNotFound)
-        end
-      end
-    end
-  end
-end

data/spec/features/checkout_spec.rb

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe 'Api Feature Specs', type: :request do
-    before do
-      stub_spree_preferences(Spree::Api::Config, requires_authentication: false)
-    end
-    let!(:promotion) { FactoryBot.create(:promotion, :with_order_adjustment, code: 'foo', weighted_order_adjustment_amount: 10) }
-    let(:promotion_code) { promotion.codes.first }
-    let!(:store) { FactoryBot.create(:store) }
-    let(:bill_address) { FactoryBot.create(:address) }
-    let(:ship_address) { FactoryBot.create(:address) }
-    let(:variant_1) { FactoryBot.create(:variant, price: 100.00) }
-    let(:variant_2) { FactoryBot.create(:variant, price: 200.00) }
-    let(:payment_method) { FactoryBot.create(:check_payment_method) }
-    let!(:shipping_method) do
-      FactoryBot.create(:shipping_method).tap do |shipping_method|
-        shipping_method.zones.first.zone_members.create!(zoneable: ship_address.country)
-        shipping_method.calculator.set_preference(:amount, 10.0)
-      end
-    end
-
-    def parsed
-      JSON.parse(response.body)
-    end
-
-    def login
-      expect {
-        post '/api/users', params: {
-          user: {
-            email: "featurecheckoutuser@example.com",
-            password: "featurecheckoutuser"
-          }
-        }
-      }.to change { Spree.user_class.count }.by 1
-      expect(response).to have_http_status(:created)
-      @user = Spree.user_class.find(parsed['id'])
-
-      # copied from api testing helpers support since we can't really sign in
-      allow(Spree::LegacyUser).to receive(:find_by).with(hash_including(:spree_api_key)) { @user }
-    end
-
-    def create_order(order_params: {})
-      expect { post '/api/orders', params: order_params }.to change { Order.count }.by 1
-      expect(response).to have_http_status(:created)
-      @order = Order.find(parsed['id'])
-      expect(@order.email).to eq "featurecheckoutuser@example.com"
-    end
-
-    def update_order(order_params: {})
-      put "/api/orders/#{@order.number}", params: order_params
-      expect(response).to have_http_status(:ok)
-    end
-
-    def create_line_item(variant, quantity = 1)
-      expect {
-        post "/api/orders/#{@order.number}/line_items",
-          params: { line_item: { variant_id: variant.id, quantity: quantity } }
-      }.to change { @order.line_items.count }.by 1
-      expect(response).to have_http_status(:created)
-    end
-
-    def add_promotion(_promotion)
-      expect {
-        post "/api/orders/#{@order.number}/coupon_codes",
-          params: { coupon_code: promotion_code.value }
-      }.to change { @order.promotions.count }.by 1
-      expect(response).to have_http_status(:ok)
-    end
-
-    def add_address(address, billing: true)
-      address_type = billing ? :bill_address : :ship_address
-      # It seems we are missing an order-scoped address api endpoint since we need
-      # to use update here.
-      expect {
-        update_order(order_params: { order: { address_type => address.attributes.except('id') } })
-      }.to change { @order.reload.public_send(address_type) }.to address
-    end
-
-    def add_payment
-      expect {
-        post "/api/orders/#{@order.number}/payments",
-          params: { payment: { payment_method_id: payment_method.id } }
-      }.to change { @order.reload.payments.count }.by 1
-      expect(response).to have_http_status(:created)
-      expect(@order.payments.last.payment_method).to eq payment_method
-    end
-
-    def advance
-      put "/api/checkouts/#{@order.number}/advance"
-      expect(response).to have_http_status(:ok)
-    end
-
-    def complete
-      put "/api/checkouts/#{@order.number}/complete"
-      expect(response).to have_http_status(:ok)
-    end
-
-    def assert_order_expectations
-      @order.reload
-      expect(@order.state).to eq 'complete'
-      expect(@order.completed_at).to be_a ActiveSupport::TimeWithZone
-      expect(@order.item_total).to eq 600.00
-      expect(@order.total).to eq 600.00
-      expect(@order.adjustment_total).to eq(-10.00)
-      expect(@order.shipment_total).to eq 10.00
-      expect(@order.user).to eq @user
-      expect(@order.bill_address).to eq bill_address
-      expect(@order.ship_address).to eq ship_address
-      expect(@order.payments.length).to eq 1
-      expect(@order.line_items.any? { |li| li.variant == variant_1 && li.quantity == 2 }).to eq true
-      expect(@order.line_items.any? { |li| li.variant == variant_2 && li.quantity == 2 }).to eq true
-      expect(@order.promotions).to eq [promotion]
-    end
-
-    it "is able to checkout with individualized requests" do
-      login
-      create_order
-
-      create_line_item(variant_1, 2)
-      add_promotion(promotion)
-      create_line_item(variant_2, 2)
-
-      add_address(bill_address)
-      add_address(ship_address, billing: false)
-
-      add_payment
-
-      advance
-      complete
-
-      assert_order_expectations
-    end
-
-    it "is able to checkout with the create request" do
-      login
-
-      create_order(order_params: {
-        order: {
-          bill_address: bill_address.as_json.except('id'),
-          ship_address: ship_address.as_json.except('id'),
-          line_items: {
-            0 => { variant_id: variant_1.id, quantity: 2 },
-            1 => { variant_id: variant_2.id, quantity: 2 }
-          },
-          # Would like to do this, but it puts the payment in a complete state,
-          # which the order does not like when transitioning from confirm to complete
-          # since it looks to process pending payments.
-          # payments: [ { payment_method: payment_method.name, state: "pending" } ],
-        }
-      })
-
-      add_promotion(promotion)
-      add_payment
-
-      advance
-      complete
-
-      assert_order_expectations
-    end
-
-    it "is able to checkout with the update request" do
-      login
-
-      create_order
-      update_order(order_params: {
-        order: {
-          bill_address: bill_address.as_json.except('id'),
-          ship_address: ship_address.as_json.except('id'),
-          line_items: {
-            0 => { variant_id: variant_1.id, quantity: 2 },
-            1 => { variant_id: variant_2.id, quantity: 2 }
-          },
-          # Would like to do this, but it puts the payment in a complete state,
-          # which the order does not like when transitioning from confirm to complete
-          # since it looks to process pending payments.
-          # payments: [ { payment_method: payment_method.name, state: "pending" } ],
-        }
-      })
-
-      add_promotion(promotion)
-      add_payment
-
-      advance
-      complete
-
-      assert_order_expectations
-    end
-  end
-end