solidus_core_devise_token_auth 2.8.0.alpha.0

data/lib/spree/testing_support/dummy_app/rake_tasks.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module DummyApp
+  class RakeTasks
+    include Rake::DSL
+
+    def initialize(gem_root:, lib_name:)
+      task :dummy_environment do
+        ENV['RAILS_ENV'] = 'test'
+        require lib_name
+        require 'spree/testing_support/dummy_app'
+        DummyApp.setup(
+          gem_root: gem_root,
+          lib_name: lib_name,
+          auto_migrate: false
+        )
+      end
+    end
+  end
+end
+
+namespace :db do
+  desc "Drops the test database"
+  task drop: :dummy_environment do
+    ActiveRecord::Tasks::DatabaseTasks.drop_current
+  end
+
+  desc "Creates the test database"
+  task create: :dummy_environment do
+    ActiveRecord::Tasks::DatabaseTasks.create_current
+  end
+
+  desc "Migrates the test database"
+  task migrate: :dummy_environment do
+    ActiveRecord::Migration.verbose = false
+
+    # We want to simulate how migrations would be run if a user ran
+    # railties:install:migrations and then db:migrate.
+    # Migrations should be run one directory at a time
+    ActiveRecord::Migrator.migrations_paths.each do |path|
+      if defined?(ActiveRecord::MigrationContext)
+        # Rails >= 5.2
+        ActiveRecord::MigrationContext.new([path]).migrate
+      else
+        ActiveRecord::Migrator.migrate(path)
+      end
+    end
+
+    ActiveRecord::Base.clear_cache!
+  end
+
+  desc "Recreates the test database and re-runs all migrations"
+  task reset: ['db:drop', 'db:create', 'db:migrate']
+end
+
+desc "Open a sandboxed console in the test environment"
+task console: :dummy_environment do
+  begin
+    require 'pry'
+    Rails.application.config.console = Pry
+  rescue LoadError
+  end
+
+  require 'rails/commands'
+  require 'rails/commands/console/console_command'
+  Rails::Console.new(Rails.application, sandbox: true, environment: "test").start
+end

data/lib/spree/testing_support/dummy_app/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+DummyApp::Application.routes.draw do
+  mount Spree::Core::Engine, at: '/'
+end

data/lib/spree/testing_support/dummy_app/views/layouts/application.html.erb

@@ -0,0 +1 @@
+<%= yield %>

data/lib/spree/testing_support/dummy_app.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+ENV['RAILS_ENV'] = 'test'
+ENV['DISABLE_DATABASE_ENVIRONMENT_CHECK'] = '1'
+
+require 'rails'
+require 'active_record/railtie'
+require 'action_controller/railtie'
+require 'action_mailer/railtie'
+
+Rails.env = 'test'
+
+require 'solidus_core'
+
+# @private
+def forgery_protected_by_default?
+  Gem::Version.new(Rails.version) >= Gem::Version.new('5.2')
+end
+
+# @private
+class ApplicationController < ActionController::Base
+  if !forgery_protected_by_default?
+    protect_from_forgery with: :exception
+  end
+end
+
+# @private
+class ApplicationRecord < ActiveRecord::Base
+end
+
+# @private
+class ApplicationMailer < ActionMailer::Base
+end
+
+# @private
+module ApplicationHelper
+end
+
+# @private
+module DummyApp
+  def self.setup(gem_root:, lib_name:, auto_migrate: true)
+    ENV["LIB_NAME"] = lib_name
+    DummyApp::Application.config.root = File.join(gem_root, 'spec', 'dummy')
+
+    DummyApp::Application.initialize!
+
+    if auto_migrate
+      DummyApp::Migrations.auto_migrate
+    end
+  end
+
+  class Application < ::Rails::Application
+    config.eager_load                                 = false
+    config.cache_classes                              = true
+    config.cache_store                                = :memory_store
+    config.serve_static_assets                        = true
+    config.public_file_server.headers                 = { 'Cache-Control' => 'public, max-age=3600' }
+    config.whiny_nils                                 = true
+    config.consider_all_requests_local                = true
+    config.action_controller.allow_forgery_protection = true
+    config.action_controller.perform_caching          = false
+    config.action_dispatch.show_exceptions            = false
+    config.active_support.deprecation                 = :stderr
+    config.action_mailer.delivery_method              = :test
+    config.active_support.deprecation                 = :stderr
+    config.secret_key_base                            = 'SECRET_TOKEN'
+
+    if forgery_protected_by_default?
+      config.action_controller.default_protect_from_forgery = true
+    end
+
+    if config.active_record.sqlite3
+      # Rails >= 5.2
+      config.active_record.sqlite3.represent_boolean_as_integer = true
+    end
+
+    # Avoid issues if an old spec/dummy still exists
+    config.paths['config/initializers'] = []
+    config.paths['config/environments'] = []
+
+    migration_dirs = Rails.application.migration_railties.flat_map do |engine|
+      if engine.respond_to?(:paths)
+        engine.paths['db/migrate'].to_a
+      else
+        []
+      end
+    end
+    config.paths['db/migrate'] = migration_dirs
+    ActiveRecord::Migrator.migrations_paths = migration_dirs
+
+    config.action_controller.include_all_helpers = false
+
+    if config.respond_to?(:assets)
+      config.assets.paths << File.expand_path('dummy_app/assets/javascripts', __dir__)
+      config.assets.paths << File.expand_path('dummy_app/assets/stylesheets', __dir__)
+    end
+
+    config.paths["config/database"] = File.expand_path('dummy_app/database.yml', __dir__)
+    config.paths['app/views'] = File.expand_path('dummy_app/views', __dir__)
+    config.paths['config/routes.rb'] = File.expand_path('dummy_app/routes.rb', __dir__)
+
+    ActionMailer::Base.default from: "store@example.com"
+  end
+end
+
+require 'spree/testing_support/dummy_app/migrations'
+
+ActiveSupport.on_load(:action_controller) do
+  wrap_parameters format: [:json]
+end
+
+Spree.user_class = 'Spree::LegacyUser'
+Spree.config do |config|
+  config.mails_from = "store@example.com"
+end
+
+# Raise on deprecation warnings
+if ENV['SOLIDUS_RAISE_DEPRECATIONS'].present?
+  Spree::Deprecation.behavior = :raise
+end

data/lib/spree/testing_support/extension_rake.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spree/testing_support/common_rake'
+
+desc "Generates a dummy app for testing an extension"
+namespace :extension do
+  task :test_app, [:user_class] do |_t, _args|
+    Spree::DummyGeneratorHelper.inject_extension_requirements = true
+    Rake::Task['common:test_app'].invoke
+  end
+end

data/lib/spree/testing_support/factories/address_factory.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spree/testing_support/factories/state_factory'
+require 'spree/testing_support/factories/country_factory'
+
+FactoryBot.define do
+  factory :address, class: 'Spree::Address' do
+    transient do
+      # There's `Spree::Address#country_iso=`, prohibiting me from using `country_iso` here
+      country_iso_code { 'US' }
+      state_code { 'AL' }
+    end
+
+    firstname { 'John' }
+    lastname { nil }
+    company { 'Company' }
+    address1 { '10 Lovely Street' }
+    address2 { 'Northwest' }
+    city { 'Herndon' }
+    sequence(:zipcode, 10001) { |i| i.to_s }
+    phone { '555-555-0199' }
+    alternative_phone { '555-555-0199' }
+
+    state do |address|
+      Spree::State.joins(:country).where('spree_countries.iso = (?)', country_iso_code).find_by(abbr: state_code) ||
+        address.association(:state, country_iso: country_iso_code, state_code: state_code)
+    end
+
+    country do |address|
+      if address.state
+        address.state.country
+      else
+        address.association(:country, iso: country_iso_code)
+      end
+    end
+  end
+
+  factory :ship_address, parent: :address do
+    address1 { 'A Different Road' }
+  end
+
+  factory :bill_address, parent: :address do
+    address1 { 'PO Box 1337' }
+  end
+end

data/lib/spree/testing_support/factories/adjustment_factory.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spree/testing_support/factories/line_item_factory'
+require 'spree/testing_support/factories/order_factory'
+require 'spree/testing_support/factories/tax_category_factory'
+require 'spree/testing_support/factories/tax_rate_factory'
+require 'spree/testing_support/factories/zone_factory'
+
+FactoryBot.define do
+  factory :adjustment, class: 'Spree::Adjustment' do
+    order
+    adjustable { order }
+    amount { 100.0 }
+    label { 'Shipping' }
+    association(:source, factory: :tax_rate)
+    eligible { true }
+
+    after(:build) do |adjustment|
+      adjustments = adjustment.adjustable.adjustments
+      if adjustments.loaded? && !adjustments.include?(adjustment)
+        adjustments.proxy_association.add_to_target(adjustment)
+      end
+    end
+
+    factory :tax_adjustment, class: 'Spree::Adjustment' do
+      order { adjustable.order }
+      association(:adjustable, factory: :line_item)
+      amount { 10.0 }
+      label { 'VAT 5%' }
+
+      after(:create) do |adjustment|
+        # Set correct tax category, so that adjustment amount is not 0
+        if adjustment.adjustable.is_a?(Spree::LineItem)
+          if adjustment.adjustable.tax_category.present?
+            adjustment.source.tax_categories = [adjustment.adjustable.tax_category]
+          else
+            adjustment.source.tax_categories = []
+          end
+          adjustment.source.save
+          adjustment.recalculate
+        end
+      end
+    end
+  end
+end

data/lib/spree/testing_support/factories/adjustment_reason_factory.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :adjustment_reason, class: 'Spree::AdjustmentReason' do
+    sequence(:name) { |n| "Refund for return ##{n}" }
+    sequence(:code) { |n| "Code #{n}" }
+  end
+end

data/lib/spree/testing_support/factories/calculator_factory.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :calculator, aliases: [:flat_rate_calculator], class: 'Spree::Calculator::FlatRate' do
+    preferred_amount { 10.0 }
+  end
+
+  factory :no_amount_calculator, class: 'Spree::Calculator::FlatRate' do
+    preferred_amount { 0 }
+  end
+
+  factory :default_tax_calculator, class: 'Spree::Calculator::DefaultTax' do
+  end
+
+  factory :shipping_calculator, class: 'Spree::Calculator::Shipping::FlatRate' do
+    preferred_amount { 10.0 }
+  end
+
+  factory :shipping_no_amount_calculator, class: 'Spree::Calculator::Shipping::FlatRate' do
+    preferred_amount { 0 }
+  end
+
+  factory :percent_on_item_calculator, class: 'Spree::Calculator::PercentOnLineItem' do
+    preferred_percent { 10 }
+  end
+end

data/lib/spree/testing_support/factories/carton_factory.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spree/testing_support/factories/shipment_factory'
+require 'spree/testing_support/factories/inventory_unit_factory'
+
+FactoryBot.define do
+  factory :carton, class: 'Spree::Carton' do
+    address
+    stock_location
+    shipping_method
+    shipped_at { Time.current }
+    inventory_units do
+      [
+        build(
+          :inventory_unit,
+          # ensure the shipment uses the same stock location as the carton
+          shipment: build(
+            :shipment,
+            stock_location: stock_location,
+            shipping_method: shipping_method
+          )
+        )
+      ]
+    end
+  end
+end

data/lib/spree/testing_support/factories/country_factory.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'carmen'
+
+FactoryBot.define do
+  factory :country, class: 'Spree::Country' do
+    iso { 'US' }
+
+    transient do
+      carmen_country { Carmen::Country.coded(iso) || fail("Unknown country iso code: #{iso.inspect}") }
+    end
+
+    iso_name { carmen_country.name.upcase }
+    name { carmen_country.name }
+    iso3 { carmen_country.alpha_3_code }
+    numcode { carmen_country.numeric_code }
+
+    # FIXME: We should set states required, but it causes failing tests
+    # states_required { carmen_country.subregions? }
+  end
+end

data/lib/spree/testing_support/factories/credit_card_factory.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :credit_card, class: 'Spree::CreditCard' do
+    verification_value { 123 }
+    month { 12 }
+    year { 1.year.from_now.year }
+    number { '4111111111111111' }
+    name { 'Spree Commerce' }
+    association(:payment_method, factory: :credit_card_payment_method)
+    association(:address)
+
+    trait :failing do
+      number { "0000000000000000" }
+    end
+  end
+end

data/lib/spree/testing_support/factories/customer_return_factory.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spree/testing_support/factories/stock_location_factory'
+require 'spree/testing_support/factories/order_factory'
+require 'spree/testing_support/factories/return_item_factory'
+
+FactoryBot.define do
+  factory :customer_return, class: 'Spree::CustomerReturn' do
+    association(:stock_location, factory: :stock_location)
+
+    transient do
+      line_items_count { 1 }
+      return_items_count { line_items_count }
+      shipped_order { create :shipped_order, line_items_count: line_items_count }
+      return_authorization { create :return_authorization, order: shipped_order }
+    end
+
+    before(:create) do |customer_return, evaluator|
+      evaluator.shipped_order.inventory_units.take(evaluator.return_items_count).each do |inventory_unit|
+        customer_return.return_items << build(:return_item, inventory_unit: inventory_unit, return_authorization: evaluator.return_authorization)
+      end
+    end
+
+    factory :customer_return_with_accepted_items do
+      after(:create) do |customer_return|
+        customer_return.return_items.each(&:accept!)
+      end
+    end
+  end
+
+  # for the case when you want to supply existing return items instead of generating some
+  factory :customer_return_without_return_items, class: 'Spree::CustomerReturn' do
+    association(:stock_location, factory: :stock_location)
+  end
+end

data/lib/spree/testing_support/factories/image_factory.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :image, class: 'Spree::Image' do
+    attachment { File.new(Spree::Core::Engine.root + 'spec/fixtures/thinking-cat.jpg') }
+  end
+end

data/lib/spree/testing_support/factories/inventory_unit_factory.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spree/testing_support/factories/line_item_factory'
+require 'spree/testing_support/factories/variant_factory'
+require 'spree/testing_support/factories/order_factory'
+require 'spree/testing_support/factories/shipment_factory'
+
+FactoryBot.define do
+  factory :inventory_unit, class: 'Spree::InventoryUnit' do
+    transient do
+      order { nil }
+    end
+
+    variant
+    line_item do
+      if order
+        build(:line_item, variant: variant, order: order)
+      else
+        build(:line_item, variant: variant)
+      end
+    end
+    state { 'on_hand' }
+    shipment { build(:shipment, state: 'pending', order: line_item.order) }
+    # return_authorization
+  end
+end

data/lib/spree/testing_support/factories/line_item_factory.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'spree/testing_support/factories/order_factory'
+require 'spree/testing_support/factories/product_factory'
+
+FactoryBot.define do
+  factory :line_item, class: 'Spree::LineItem' do
+    quantity { 1 }
+    price { BigDecimal('10.00') }
+    order
+    transient do
+      product { nil }
+    end
+    variant do
+      (product || create(:product)).master
+    end
+  end
+end

data/lib/spree/testing_support/factories/option_type_factory.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :option_type, class: 'Spree::OptionType' do
+    sequence(:name) { |n| "foo-size-#{n}" }
+    presentation { 'Size' }
+  end
+end

data/lib/spree/testing_support/factories/option_value_factory.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :option_value, class: 'Spree::OptionValue' do
+    sequence(:name) { |n| "Size-#{n}" }
+
+    presentation { 'S' }
+    option_type
+  end
+end

data/lib/spree/testing_support/factories/order_factory.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'spree/testing_support/factories/address_factory'
+require 'spree/testing_support/factories/shipment_factory'
+require 'spree/testing_support/factories/store_factory'
+require 'spree/testing_support/factories/user_factory'
+require 'spree/testing_support/factories/line_item_factory'
+require 'spree/testing_support/factories/payment_factory'
+
+FactoryBot.define do
+  factory :order, class: 'Spree::Order' do
+    user
+    bill_address
+    ship_address
+    completed_at { nil }
+    email { user.try(:email) }
+    store
+
+    transient do
+      line_items_price { BigDecimal(10) }
+    end
+
+    # TODO: Improve the name of order_with_totals factory.
+    factory :order_with_totals do
+      after(:build) do |order, evaluator|
+        order.line_items << build(
+          :line_item,
+          order: order,
+          price: evaluator.line_items_price
+        )
+      end
+
+      after(:create) do |order|
+        order.recalculate
+      end
+    end
+
+    factory :order_with_line_items do
+      bill_address
+      ship_address
+
+      transient do
+        line_items_count { 1 }
+        line_items_attributes { [{}] * line_items_count }
+        shipment_cost { 100 }
+        shipping_method { nil }
+        stock_location { create(:stock_location) }
+      end
+
+      after(:build) do |order, evaluator|
+        evaluator.stock_location # must evaluate before creating line items
+
+        evaluator.line_items_attributes.each do |attributes|
+          attributes = { order: order, price: evaluator.line_items_price }.merge(attributes)
+          create(:line_item, attributes)
+        end
+        order.line_items.reload
+
+        create(:shipment, order: order, cost: evaluator.shipment_cost, shipping_method: evaluator.shipping_method, stock_location: evaluator.stock_location)
+        order.shipments.reload
+
+        order.recalculate
+      end
+
+      factory :completed_order_with_promotion do
+        transient do
+          promotion { nil }
+        end
+
+        after(:create) do |order, evaluator|
+          promotion = evaluator.promotion || create(:promotion, code: "test")
+          promotion_code = promotion.codes.first || create(:promotion_code, promotion: promotion)
+
+          promotion.activate(order: order, promotion_code: promotion_code)
+          order.order_promotions.create!(promotion: promotion, promotion_code: promotion_code)
+
+          # Complete the order after the promotion has been activated
+          order.update_column(:completed_at, Time.current)
+          order.update_column(:state, "complete")
+        end
+      end
+
+      factory :order_ready_to_complete do
+        state { 'confirm' }
+        payment_state { 'checkout' }
+
+        transient do
+          payment_type { :credit_card_payment }
+        end
+
+        after(:create) do |order, evaluator|
+          create(evaluator.payment_type, {
+            amount: order.total,
+            order: order,
+            state: order.payment_state
+          })
+
+          order.payments.reload
+        end
+      end
+
+      factory :completed_order_with_totals do
+        state { 'complete' }
+
+        after(:create) do |order|
+          order.shipments.each do |shipment|
+            shipment.inventory_units.update_all state: 'on_hand', pending: false
+          end
+          order.update_column(:completed_at, Time.current)
+        end
+
+        factory :completed_order_with_pending_payment do
+          after(:create) do |order|
+            create(:payment, amount: order.total, order: order, state: 'pending')
+          end
+        end
+
+        factory :order_ready_to_ship do
+          payment_state { 'paid' }
+          shipment_state { 'ready' }
+
+          transient do
+            payment_type { :credit_card_payment }
+          end
+
+          after(:create) do |order, evaluator|
+            create(evaluator.payment_type, amount: order.total, order: order, state: 'completed')
+            order.shipments.each do |shipment|
+              shipment.update_column('state', 'ready')
+            end
+            order.reload
+          end
+
+          factory :shipped_order do
+            transient do
+              with_cartons { true }
+            end
+            after(:create) do |order, evaluator|
+              order.shipments.each do |shipment|
+                shipment.inventory_units.update_all state: 'shipped'
+                shipment.update_columns(state: 'shipped', shipped_at: Time.current)
+                next unless evaluator.with_cartons
+                Spree::Carton.create!(
+                  stock_location: shipment.stock_location,
+                  address: order.ship_address,
+                  shipping_method: shipment.shipping_method,
+                  inventory_units: shipment.inventory_units,
+                  shipped_at: Time.current
+                )
+              end
+              # We need to update the shipment_state after all callbacks have run
+              order.update_columns(shipment_state: 'shipped')
+              order.reload
+            end
+          end
+        end
+      end
+    end
+  end
+end