spree_core 5.6.1 → 6.0.0.beta2

data/lib/spree/testing_support/action_text.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Spree 6.0 stores rich text in its own columns and neither loads Action Text
+# nor creates its tables. The upgrade tasks still read
+# +action_text_rich_texts+ to copy legacy content out of it, so specs covering
+# those tasks have to stand the pre-upgrade table up themselves.
+#
+#   RSpec.describe '...' do
+#     include_context 'with legacy Action Text'
+#   end
+RSpec.shared_context 'with legacy Action Text' do
+  before(:all) do
+    require 'action_text/engine'
+
+    connection = ActiveRecord::Base.connection
+    unless connection.table_exists?(:action_text_rich_texts)
+      connection.create_table :action_text_rich_texts do |t|
+        t.string :name, null: false
+        t.text :body
+        t.string :record_type, null: false
+        t.bigint :record_id, null: false
+        t.string :locale, null: false, default: 'en'
+        t.timestamps
+      end
+    end
+
+    ActionText::RichText.reset_column_information
+  end
+
+  after(:all) do
+    ActiveRecord::Base.connection.drop_table(:action_text_rich_texts, if_exists: true)
+  end
+end

data/lib/spree/testing_support/common_rake.rb

@@ -3,17 +3,13 @@ require 'generators/spree/dummy_model/dummy_model_generator'
 
 desc 'Generates a dummy app for testing'
 namespace :common do
-  task :test_app, [:authentication, :user_class, :admin_user_class, :css, :javascript, :install_admin, :install_storefront] do |_t, args|
+  task :test_app, [:authentication, :user_class, :admin_user_class] do |_t, args|
     # Support both Rake::TaskArguments (via invoke) and Hash (via execute)
     # When using execute with a Hash, args IS the hash directly
     defaults = {
       authentication: 'dummy',
-      user_class: 'Spree::LegacyUser',
-      admin_user_class: 'Spree::LegacyAdminUser',
-      install_storefront: false,
-      install_admin: false,
-      javascript: false,
-      css: false
+      user_class: 'Spree::Customer',
+      admin_user_class: 'Spree::AdminUser',
     }
     # Rake::TaskArguments#with_defaults modifies in-place
     # ActiveSupport adds Hash#with_defaults which returns a new hash, so check for Rake::TaskArguments specifically
@@ -25,15 +21,6 @@ namespace :common do
     end
     require ENV['LIB_NAME'].to_s
 
-    # Convert to booleans (supports both string and boolean values for backwards compatibility)
-    install_admin = args[:install_admin].to_b
-    install_storefront = args[:install_storefront].to_b
-    javascript_enabled = args[:javascript].to_b
-    css_enabled = args[:css].to_b
-
-    # Admin and Storefront require CSS (Tailwind) to function properly
-    css_enabled ||= install_admin || install_storefront
-
     puts args
 
     ENV['RAILS_ENV'] = 'test'
@@ -42,32 +29,15 @@ namespace :common do
     dummy_app_args = [
       "--lib_name=#{ENV['LIB_NAME']}"
     ]
-    dummy_app_args << '--javascript' if javascript_enabled
-    dummy_app_args << '--css=tailwind' if css_enabled
 
     puts dummy_app_args
 
     Spree::DummyGenerator.start dummy_app_args
 
-    # Install JavaScript dependencies (importmap, turbo, stimulus) if JavaScript is enabled
-    # Rails includes the gems but doesn't run the installers automatically
-    if javascript_enabled
-      puts 'Installing JavaScript dependencies...'
-      system('yes | bundle exec rails importmap:install turbo:install stimulus:install')
-    end
-
-    # install devise if it's not the legacy user, useful for testing storefront
-    if args[:authentication] == 'devise' && args[:user_class] != 'Spree::LegacyUser'
-      system('bundle exec rails g devise:install --force --auto-accept')
-      system("bundle exec rails g devise #{args[:user_class]} --force --auto-accept")
-      system("bundle exec rails g devise #{args[:admin_user_class]} --force --auto-accept") if args[:admin_user_class].present? && args[:admin_user_class] != args[:user_class]
-      system('rm -rf spec') # we need to cleanup factories created by devise to avoid naming conflict
-    end
-
     # Run core Spree install generator
     # The spree:install generator lives in the root spree gem. Core gems (spree_core, spree_api)
     # don't have spree as a dependency, so we need to use the root Gemfile to access the generator.
-    # Other gems (admin, storefront, etc.) already have spree in their Gemfile.
+    # Other gems already have spree in their Gemfile.
     core_gems = %w[spree/core spree/api]
     root_gemfile = File.expand_path('../../../../Gemfile', __dir__)
     use_root_gemfile = core_gems.include?(ENV['LIB_NAME']) &&
@@ -77,31 +47,6 @@ namespace :common do
     puts 'Running Spree install generator...'
     system("#{bundle_exec} rails g spree:install --force --auto-accept --migrate=false --seed=false --sample=false --user_class=#{args[:user_class]} --admin_user_class=#{args[:admin_user_class]} --authentication=#{args[:authentication]}")
 
-    # Determine if we need to install admin/storefront
-    # Either via explicit flag or because we're testing that gem itself
-    needs_admin = install_admin || ENV['LIB_NAME'] == 'spree/admin'
-    needs_storefront = install_storefront || ENV['LIB_NAME'] == 'spree/storefront'
-
-    # Run admin install generator if requested or testing admin gem
-    if needs_admin
-      # Only run install if explicitly requested (not when testing admin gem itself)
-      if install_admin
-        puts 'Running Spree Admin install generator...'
-        system('bundle exec rails g spree:admin:install --force')
-      end
-      system('bundle exec rails g spree:admin:devise --force') if args[:authentication] == 'devise'
-    end
-
-    # Run storefront install generator if requested or testing storefront gem
-    if needs_storefront
-      # Only run install if explicitly requested (not when testing storefront gem itself)
-      if install_storefront
-        puts 'Running Spree Storefront install generator...'
-        system('bundle exec rails g spree:storefront:install --force --migrate=false')
-      end
-      system('bundle exec rails g spree:storefront:devise --force') if args[:authentication] == 'devise'
-    end
-
     unless ENV['NO_MIGRATE']
       puts 'Setting up dummy database...'
       system('bundle exec rails db:environment:set RAILS_ENV=test > /dev/null 2>&1')
@@ -123,13 +68,6 @@ namespace :common do
       puts "Error loading generator: #{e.message}"
       puts 'Skipping installation no generator to run...'
     end
-
-    # Precompile assets after all generators have run
-    # This ensures CSS entry points (like Spree Admin's Tailwind CSS) are created first
-    if javascript_enabled || css_enabled
-      puts 'Precompiling assets...'
-      system('bundle exec rake assets:precompile')
-    end
   end
 
   task :db_setup do |_t|

data/lib/spree/testing_support/country_pool.rb

@@ -0,0 +1,50 @@
+module Spree
+  module TestingSupport
+    # Real ISO codes for the :country factory to cycle through.
+    #
+    # Country records only mean anything if their code is one the countries gem
+    # knows — that is what resolves subdivisions, names and currencies — so the
+    # factory can't invent codes the way it used to.
+    #
+    # US is excluded: it is the default store's country and specs asking for
+    # "a different country" would otherwise collide with it.
+    module CountryPool
+      ISO_CODES = %w[
+        PL DE FR GB IT ES NL BE SE NO DK FI PT AT CH IE GR CZ HU RO
+        CA MX BR AR CL AU NZ JP CN IN ZA
+      ].freeze
+
+      # @param index [Integer] any counter; wraps around the pool
+      # @return [String] a real alpha-2 code
+      def self.iso_for(index)
+        ISO_CODES[index.to_i % ISO_CODES.size]
+      end
+
+      # Codes whose subdivisions the gem knows, for state-bearing specs.
+      # @return [Array<String>]
+      def self.with_subdivisions
+        @with_subdivisions ||= ISO_CODES.select { |iso| Spree::IsoData.subdivisions(iso).any? }
+      end
+
+      # A postal code the country actually accepts. Addresses are validated
+      # against per-country formats, so a single hardcoded value cannot serve
+      # every country the factory might pick.
+      POSTAL_CODES = {
+        'US' => '10118', 'CA' => 'K1A 0B1', 'GB' => 'SW1A 1AA', 'PL' => '00-001',
+        'DE' => '10115', 'FR' => '75001', 'IT' => '00100', 'ES' => '28001',
+        'NL' => '1011 AB', 'BE' => '1000', 'SE' => '111 20', 'NO' => '0010',
+        'DK' => '1050', 'FI' => '00100', 'PT' => '1000-001', 'AT' => '1010',
+        'CH' => '8001', 'IE' => 'D02 AF30', 'GR' => '104 31', 'CZ' => '110 00',
+        'HU' => '1011', 'RO' => '010011', 'MX' => '01000', 'BR' => '01310-100',
+        'AR' => 'C1002', 'CL' => '8320000', 'AU' => '2000', 'NZ' => '6011',
+        'JP' => '100-0001', 'CN' => '100000', 'IN' => '110001', 'ZA' => '0001'
+      }.freeze
+
+      # @param iso [String, nil]
+      # @return [String] a postal code valid for that country
+      def self.postal_code_for(iso)
+        POSTAL_CODES.fetch(iso.to_s.upcase, '10118')
+      end
+    end
+  end
+end

data/lib/spree/testing_support/extension_rake.rb

@@ -7,15 +7,11 @@ namespace :extension do
     # Support both hash passed as first arg and named options
     options = args[:options].is_a?(Hash) ? args[:options] : args.to_h
     Rake::Task['common:test_app'].execute(Rake::TaskArguments.new(
-      [:authentication, :user_class, :admin_user_class, :css, :javascript, :install_admin, :install_storefront],
+      [:authentication, :user_class, :admin_user_class],
       [
         options[:authentication],
         options[:user_class],
-        options[:admin_user_class],
-        options[:css],
-        options[:javascript],
-        options[:install_admin],
-        options[:install_storefront]
+        options[:admin_user_class]
       ]
     ))
   end

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

@@ -1,30 +1,60 @@
 FactoryBot.define do
   factory :address, aliases: [:bill_address, :ship_address], class: Spree::Address do
-    firstname         { 'John' }
-    lastname          { 'Doe' }
+    first_name         { 'John' }
+    last_name          { 'Doe' }
     company           { 'Company' }
     sequence(:address1) { |n| "#{n} Lovely Street" }
     address2          { 'Northwest' }
     city              { 'New York' }
-    zipcode           { '10118' }
     phone             { '555-555-0199' }
     alternative_phone { '555-555-0199' }
 
-    # Default to a real US/NY pair (cached via find_or_create_by) so generated
-    # OpenAPI examples carry plausible country/state fields. Tests that need a
-    # different state/country pass them explicitly.
-    country do
-      Spree::Country.find_or_create_by!(iso: 'US') do |c|
-        c.iso3 = 'USA'
-        c.name = 'United States of America'
-        c.iso_name = 'UNITED STATES'
-        c.numcode = 840
-        c.states_required = true
+    # A real US/NY pair, so generated OpenAPI examples carry plausible fields
+    # and address validation has a subdivision it recognises. The model stores
+    # plain codes; country/state stay as transient value objects so specs can
+    # keep passing them (or country_code/state_code directly).
+    transient do
+      # The owner is polymorphic; these keep the customer case readable, since
+      # a customer's address book is what most specs are building.
+      customer { nil }
+      user { nil }
+
+      country { Spree::Country.by_iso('US') }
+
+      # NY only when the country is actually the US — specs that pass a
+      # different country get one of its own subdivisions instead of an
+      # invalid pairing.
+      state do
+        if country.nil?
+          nil
+        elsif country.iso == 'US'
+          create(:state, country: country, abbr: 'NY')
+        else
+          create(:state, country: country)
+        end
       end
     end
 
-    state do |address|
-      (address.country || Spree::Country.find_by(iso: 'US'))&.states&.find_or_create_by!(abbr: 'NY') { |s| s.name = 'New York' }
+    country_code { country&.iso }
+    state_code { state&.abbr }
+
+    # Countries now carry their real postal formats, so a US ZIP would be
+    # rejected everywhere else. Specs that care about a particular code pass
+    # one; the rest just need something the country accepts.
+    postal_code { Spree::TestingSupport::CountryPool.postal_code_for(country&.iso) }
+
+    after(:build) do |address, evaluator|
+      owner = evaluator.customer || evaluator.user
+      address.owner = owner if owner
+    end
+
+    # An address addressed to a business rather than a person. What it asks
+    # for follows from its owner, so naming one is the whole difference.
+    factory :business_address do
+      association :owner, factory: :seller
+      first_name { nil }
+      last_name  { nil }
+      company   { 'Acme Industrial' }
     end
   end
 end

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

@@ -1,6 +1,6 @@
 FactoryBot.define do
   factory :api_key, class: Spree::ApiKey do
-    name { FFaker::Lorem.word }
+    sequence(:name) { |n| "API key #{n}" }
     key_type { 'publishable' }
     store
 

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

@@ -7,9 +7,6 @@ FactoryBot.define 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

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

@@ -0,0 +1,60 @@
+FactoryBot.define do
+  factory :cart, class: Spree::Cart do
+    store { Spree::Store.find_by(default: true) || association(:store) }
+    currency { 'USD' }
+
+    factory :cart_with_line_items do
+      transient do
+        line_items_count { 1 }
+        line_items_price { BigDecimal(10) }
+      end
+
+      after(:create) do |cart, evaluator|
+        create_list(:line_item, evaluator.line_items_count, cart: cart, order: nil, price: evaluator.line_items_price)
+        cart.line_items.reload
+        cart.recalculate_totals!
+      end
+
+      # Mid-checkout: addresses set and delivery proposals built against a
+      # real shipping method — the factory replacement for
+      # OrderWalkthrough.up_to(:payment).
+      factory :cart_ready_for_delivery do
+        email { 'buyer@example.com' }
+
+        transient do
+          shipping_cost { 10 }
+        end
+
+        after(:create) do |cart, evaluator|
+          create(:check_payment_method, store: cart.store) if Spree::PaymentMethod.none?
+
+          country = Spree::Country.by_iso('US')
+
+          if Spree::DeliveryMethod.none?
+            create(:shipping_method).tap do |delivery_method|
+              delivery_method.calculator.preferred_amount = evaluator.shipping_cost
+              delivery_method.calculator.preferred_currency = cart.store.default_currency
+              delivery_method.calculator.save!
+            end
+          end
+
+          cart.update!(
+            ship_address: create(:address, country: country, state: country.states.first),
+            bill_address: create(:address, country: country, state: country.states.first)
+          )
+          cart.rebuild_fulfillments!
+          cart.set_fulfillments_cost
+          cart.recalculate_totals!
+        end
+
+        # Payment-covered and completable — the factory replacement for a
+        # walkthrough cart with a full check payment.
+        factory :cart_ready_to_complete do
+          after(:create) do |cart|
+            create(:payment, cart: cart, order: nil, payment_method: Spree::PaymentMethod.first, amount: cart.reload.total)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+FactoryBot.define do
+  factory :catalog, class: Spree::Catalog do
+    sequence(:name) { |n| "Wholesale Catalog #{n}" }
+    store { Spree::Store.default || create(:store) }
+    # A catalog is born inactive and goes live through Catalogs::Activate, but
+    # a spec that builds one almost always wants an agreement that applies —
+    # `:inactive` is the trait for testing the other side.
+    active { true }
+
+    trait :inactive do
+      active { false }
+    end
+  end
+
+  factory :catalog_product, class: Spree::CatalogProduct do
+    catalog
+    product { association(:product, store: catalog.store) }
+  end
+
+  factory :catalog_assignment, class: Spree::CatalogAssignment do
+    catalog
+    assignable { association(:company, store: catalog.store) }
+  end
+
+  factory :catalog_quantity_rule, class: Spree::CatalogQuantityRule do
+    catalog
+    variant { association(:variant, product: association(:product, store: catalog.store)) }
+    minimum_order_quantity { 48 }
+    order_multiple { 24 }
+  end
+
+  factory :catalog_order_minimum, class: Spree::CatalogOrderMinimum do
+    catalog
+    currency { 'USD' }
+    amount { 500 }
+  end
+end

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

@@ -0,0 +1,21 @@
+FactoryBot.define do
+  # No store attribute: Category#ensure_store resolves one from the parent, the
+  # taxonomy, or the current store — so a child lands in its parent's store
+  # rather than being forced into the default.
+  factory :category, class: Spree::Category do
+    sequence(:name) { |n| "category_#{n}" }
+
+    parent { nil }
+
+    trait :with_description do
+      description { '<div>Test <strong>description</strong></div>' }
+    end
+
+    trait :with_header_image do
+      after(:create) do |category|
+        category.image.attach(io: File.new(Spree::Core::Engine.root.join('spec', 'fixtures', 'thinking-cat.jpg')), filename: 'thinking-cat.jpg')
+        category.save!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+FactoryBot.define do
+  factory :claim, class: Spree::Claim do
+    transient do
+      line_items_count { 1 }
+      send_replacement { false }
+    end
+
+    association(:order, factory: :shipped_order)
+    store { order.store }
+    status { Spree::Claim.default_status }
+    memo { 'Arrived with a cracked screen' }
+
+    after(:build) do |claim, evaluator|
+      next if claim.claim_line_items.any?
+
+      claim.order.line_items.limit(evaluator.line_items_count).each do |line_item|
+        claim.claim_line_items.build(
+          line_item: line_item,
+          variant: line_item.variant,
+          quantity: 1,
+          send_replacement: evaluator.send_replacement,
+          refund_amount: evaluator.send_replacement ? 0 : line_item.price,
+          description: 'Screen is cracked'
+        )
+      end
+    end
+
+    factory :approved_claim do
+      status { 'approved' }
+      approved_at { Time.current }
+    end
+  end
+end

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

@@ -1,7 +1,8 @@
 FactoryBot.define do
-  factory :classification, class: Spree::Classification do
+  # :classification is the pre-6.0 name, kept as an alias of the renamed :product_category.
+  factory :product_category, class: Spree::ProductCategory, aliases: [:classification] do
     product
-    taxon
+    category
 
     position { 1 }
   end

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

@@ -0,0 +1,25 @@
+FactoryBot.define do
+  factory :collection, class: Spree::Collection do
+    sequence(:name) { |n| "collection_#{n}" }
+    store { Spree::Store.default }
+
+    trait :with_description do
+      description { '<div>Test <strong>description</strong></div>' }
+    end
+
+    trait :with_image do
+      after(:create) do |collection|
+        collection.image.attach(io: File.new(Spree::Core::Engine.root.join('spec', 'fixtures', 'thinking-cat.jpg')), filename: 'thinking-cat.jpg')
+      end
+    end
+  end
+
+  factory :automatic_collection, parent: :collection do
+    automatic { true }
+    rules_match_policy { 'all' }
+
+    trait :any_match_policy do
+      rules_match_policy { 'any' }
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+FactoryBot.define do
+  factory :sale_collection_rule, class: Spree::CollectionRules::Sale do
+    value { true }
+
+    trait :is_equal_to do
+      match_policy { 'is_equal_to' }
+    end
+
+    trait :is_not_equal_to do
+      match_policy { 'is_not_equal_to' }
+    end
+
+    trait :contains do
+      match_policy { 'contains' }
+    end
+
+    trait :does_not_contain do
+      match_policy { 'does_not_contain' }
+    end
+  end
+
+  factory :tag_collection_rule, class: Spree::CollectionRules::Tag do
+    trait :is_equal_to do
+      match_policy { 'is_equal_to' }
+    end
+
+    trait :is_not_equal_to do
+      match_policy { 'is_not_equal_to' }
+    end
+
+    trait :contains do
+      match_policy { 'contains' }
+    end
+
+    trait :does_not_contain do
+      match_policy { 'does_not_contain' }
+    end
+  end
+
+  factory :available_on_collection_rule, class: Spree::CollectionRules::AvailableOn do
+    value { 30 }
+
+    trait :is_equal_to do
+      match_policy { 'is_equal_to' }
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+FactoryBot.define do
+  factory :commission_rate, class: Spree::CommissionRate do
+    sequence(:name) { |n| "Commission rate #{n}" }
+    store { Spree::Store.default || create(:store) }
+    kind { 'percentage' }
+    value { 10 }
+    enabled { true }
+
+    trait :fixed do
+      kind { 'fixed' }
+      value { 0 }
+      transient { amounts { { 'USD' => 2.5 } } }
+
+      after(:build) { |rate, evaluator| rate.amounts = evaluator.amounts }
+    end
+
+    trait :disabled do
+      enabled { false }
+    end
+
+
+    trait :with_shipping do
+      include_shipping { true }
+    end
+
+    trait :gross_base do
+      tax_inclusive { true }
+    end
+  end
+
+  # Reference lists go through the preference writers, so ids are
+  # scope-checked in specs exactly as they are through the API.
+  factory :commission_seller_rule, class: Spree::CommissionRules::SellerRule do
+    commission_rate { create(:commission_rate) }
+    transient { sellers { [] } }
+
+    after(:build) do |rule, evaluator|
+      rule.preferred_seller_ids = Array(evaluator.sellers).map(&:id) if evaluator.sellers.present?
+    end
+  end
+
+  factory :commission_category_rule, class: Spree::CommissionRules::CategoryRule do
+    commission_rate { create(:commission_rate) }
+    transient { categories { [] } }
+
+    after(:build) do |rule, evaluator|
+      rule.preferred_category_ids = Array(evaluator.categories).map(&:id) if evaluator.categories.present?
+    end
+  end
+
+  factory :commission_product_rule, class: Spree::CommissionRules::ProductRule do
+    commission_rate { create(:commission_rate) }
+    transient { products { [] } }
+
+    after(:create) do |rule, evaluator|
+      rule.products = Array(evaluator.products) if evaluator.products.present?
+    end
+  end
+
+  factory :commission_item_total_rule, class: Spree::CommissionRules::ItemTotalRule do
+    commission_rate { create(:commission_rate) }
+  end
+
+  factory :commission_line, class: Spree::CommissionLine do
+    order { create(:order) }
+    seller { create(:seller) }
+    line_item { create(:line_item) }
+    kind { 'percentage' }
+    rate { 10 }
+    amount { 10 }
+    tax_amount { 0 }
+    total { 10 }
+    currency { 'USD' }
+  end
+end

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

@@ -0,0 +1,31 @@
+FactoryBot.define do
+  factory :company, class: Spree::Company do
+    sequence(:name) { |n| "Acme Corp #{n}" }
+    store { Spree::Store.default || create(:store) }
+    kind { 'company' }
+
+    factory :company_division do
+      sequence(:name) { |n| "Division #{n}" }
+      kind { 'division' }
+      parent { association(:company, store: store) }
+    end
+  end
+
+  # A company node's address book entry: an ordinary address the node owns.
+  factory :company_address, parent: :address do
+    association :owner, factory: :company
+    first_name { nil }
+    last_name  { nil }
+    sequence(:label) { |n| "Site #{n}" }
+  end
+
+  factory :company_membership, class: Spree::CompanyMembership do
+    company
+    customer
+  end
+
+  factory :company_invitation, class: Spree::CompanyInvitation do
+    company
+    sequence(:email) { |n| "buyer#{n}@example.com" }
+  end
+end

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

@@ -0,0 +1,10 @@
+FactoryBot.define do
+  factory :consent_record, class: Spree::ConsentRecord do
+    store { Spree::Store.default || create(:store) }
+    owner { create(:customer) }
+    purpose { Spree::ConsentRecord::TERMS_OF_SERVICE }
+    source { 'registration' }
+    accepted { true }
+    email { owner.try(:email) }
+  end
+end