Merge pull request #1430 from internetee/1428-new-force-delete-procedures

Add new ForceDelete procedures

app/controllers/admin/domains/force_delete_controller.rb

@@ -5,21 +5,25 @@ module Admin
         authorize! :manage, domain
 
         domain.transaction do
-          domain.schedule_force_delete
+          domain.schedule_force_delete(type: force_delete_type)
           domain.registrar.notifications.create!(text: t('force_delete_set_on_domain',
                                                          domain_name: domain.name))
 
-          if notify_by_email?
-            DomainDeleteMailer.forced(domain: domain,
-                                      registrar: domain.registrar,
-                                      registrant: domain.registrant,
-                                      template_name: params[:template_name]).deliver_now
-          end
+          notify_by_email if notify_by_email?
         end
 
         redirect_to edit_admin_domain_url(domain), notice: t('.scheduled')
       end
 
+      def notify_by_email
+        if force_delete_type == :fast_track
+          send_email
+          domain.update(contact_notification_sent_date: Time.zone.today)
+        else
+          domain.update(template_name: params[:template_name])
+        end
+      end
+
       def destroy
         authorize! :manage, domain
         domain.cancel_force_delete
@@ -35,6 +39,21 @@ module Admin
       def notify_by_email?
         ActiveRecord::Type::Boolean.new.cast(params[:notify_by_email])
       end
+
+      def send_email
+        DomainDeleteMailer.forced(domain: domain,
+                                  registrar: domain.registrar,
+                                  registrant: domain.registrant,
+                                  template_name: params[:template_name]).deliver_now
+      end
+
+      def force_delete_type
+        soft_delete? ? :soft : :fast_track
+      end
+
+      def soft_delete?
+        ActiveRecord::Type::Boolean.new.cast(params[:soft_delete])
+      end
     end
   end
 end

app/controllers/registrant/domains_controller.rb

@@ -76,4 +76,4 @@ class Registrant::DomainsController < RegistrantController
     params.require(:q).permit(:name_matches, :registrant_ident_eq, :valid_to_gteq, :valid_to_lteq,
                               :results_per_page)
   end
-end
+end

app/models/concerns/domain/force_delete.rb

@@ -1,32 +1,106 @@
-module Concerns::Domain::ForceDelete
+module Concerns::Domain::ForceDelete # rubocop:disable Metrics/ModuleLength
   extend ActiveSupport::Concern
 
+  included do
+    store_accessor :force_delete_data,
+                   :force_delete_type,
+                   :contact_notification_sent_date,
+                   :template_name
+
+    scope :notification_not_sent,
+          lambda {
+            where("(force_delete_data->>'contact_notification_sent_date') is null")
+          }
+  end
+
+  class_methods do
+    def force_delete_scheduled
+      where('force_delete_start <= ?', Time.zone.now)
+    end
+  end
+
   def force_delete_scheduled?
     statuses.include?(DomainStatus::FORCE_DELETE)
   end
 
-  def schedule_force_delete
+  def should_notify_on_soft_force_delete?
+    force_delete_scheduled? && contact_notification_sent_date.blank? &&
+      force_delete_start.to_date <= Time.zone.now.to_date && force_delete_type.to_sym == :soft
+  end
+
+  def client_holdable?
+    force_delete_scheduled? && !statuses.include?(DomainStatus::CLIENT_HOLD) &&
+      force_delete_start.present? && force_delete_lte_today && force_delete_lte_valid_date
+  end
+
+  def force_delete_lte_today
+    force_delete_start + Setting.expire_warning_period.days <= Time.zone.now
+  end
+
+  def force_delete_lte_valid_date
+    force_delete_start + Setting.expire_warning_period.days <= valid_to
+  end
+
+  def schedule_force_delete(type: :fast_track)
     if discarded?
       raise StandardError, 'Force delete procedure cannot be scheduled while a domain is discarded'
     end
 
+    type == :fast_track ? force_delete_fast_track : force_delete_soft
+  end
+
+  def add_force_delete_type(force_delete_type)
+    self.force_delete_type = force_delete_type
+  end
+
+  def force_delete_fast_track
     preserve_current_statuses_for_force_delete
     add_force_delete_statuses
-    self.force_delete_date = Time.zone.today + Setting.redemption_grace_period.days + 1.day
+    add_force_delete_type(:fast)
+    self.force_delete_date = force_delete_fast_track_start_date + 1.day
+    self.force_delete_start = Time.zone.today + 1.day
     stop_all_pending_actions
     allow_deletion
     save(validate: false)
   end
 
-  def cancel_force_delete
-    restore_statuses_before_force_delete
-    remove_force_delete_statuses
-    self.force_delete_date = nil
+  def force_delete_soft
+    preserve_current_statuses_for_force_delete
+    add_force_delete_statuses
+    add_force_delete_type(:soft)
+    calculate_soft_delete_date
+    stop_all_pending_actions
+    allow_deletion
     save(validate: false)
   end
 
+  def clear_force_delete_data
+    self.force_delete_data = nil
+  end
+
+  def cancel_force_delete
+    restore_statuses_before_force_delete
+    remove_force_delete_statuses
+    clear_force_delete_data
+    self.force_delete_date = nil
+    self.force_delete_start = nil
+    save(validate: false)
+    registrar.notifications.create!(text: I18n.t('force_delete_cancelled', domain_name: name))
+  end
+
   private
 
+  def calculate_soft_delete_date
+    years = (valid_to.to_date - Time.zone.today).to_i / 365
+    soft_delete_dates(years) if years.positive?
+  end
+
+  def soft_delete_dates(years)
+    self.force_delete_start = valid_to - years.years + 1.day
+    self.force_delete_date = force_delete_start + Setting.expire_warning_period.days +
+                             Setting.redemption_grace_period.days
+  end
+
   def stop_all_pending_actions
     statuses.delete(DomainStatus::PENDING_UPDATE)
     statuses.delete(DomainStatus::PENDING_TRANSFER)
@@ -47,25 +121,21 @@ module Concerns::Domain::ForceDelete
     statuses << DomainStatus::FORCE_DELETE
     statuses << DomainStatus::SERVER_RENEW_PROHIBITED
     statuses << DomainStatus::SERVER_TRANSFER_PROHIBITED
-    statuses << DomainStatus::SERVER_UPDATE_PROHIBITED
-    statuses << DomainStatus::PENDING_DELETE
-
-    if (statuses & [DomainStatus::SERVER_HOLD, DomainStatus::CLIENT_HOLD]).empty?
-      statuses << DomainStatus::SERVER_MANUAL_INZONE
-    end
   end
 
   def remove_force_delete_statuses
     statuses.delete(DomainStatus::FORCE_DELETE)
     statuses.delete(DomainStatus::SERVER_RENEW_PROHIBITED)
     statuses.delete(DomainStatus::SERVER_TRANSFER_PROHIBITED)
-    statuses.delete(DomainStatus::SERVER_UPDATE_PROHIBITED)
-    statuses.delete(DomainStatus::PENDING_DELETE)
-    statuses.delete(DomainStatus::SERVER_MANUAL_INZONE)
+    statuses.delete(DomainStatus::CLIENT_HOLD)
   end
 
   def allow_deletion
     statuses.delete(DomainStatus::CLIENT_DELETE_PROHIBITED)
     statuses.delete(DomainStatus::SERVER_DELETE_PROHIBITED)
   end
+
+  def force_delete_fast_track_start_date
+    Time.zone.today + Setting.expire_warning_period.days + Setting.redemption_grace_period.days
+  end
 end

app/models/concerns/job/force_delete.rb

@@ -0,0 +1,31 @@
+module Concerns
+  module Job
+    module ForceDelete
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def start_client_hold
+          log_prepare_client_hold
+
+          ::PaperTrail.whodunnit = "cron - #{__method__}"
+
+          ::Domain.force_delete_scheduled.each do |domain|
+            proceed_client_hold(domain: domain)
+            log_end_end_client_hold(domain)
+          end
+        end
+
+        def proceed_client_hold(domain:)
+          notify_on_grace_period(domain) if domain.should_notify_on_soft_force_delete?
+          return unless domain.client_holdable?
+
+          domain.statuses << DomainStatus::CLIENT_HOLD
+          log_start_client_hold(domain)
+
+          domain.save(validate: false)
+          notify_client_hold(domain)
+        end
+      end
+    end
+  end
+end

app/models/concerns/job/force_delete_logging.rb

@@ -0,0 +1,28 @@
+module Concerns
+  module Job
+    module ForceDeleteLogging
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def log_prepare_client_hold
+          return if Rails.env.test?
+
+          STDOUT << "#{Time.zone.now.utc} - Setting client_hold to domains\n"
+        end
+
+        def log_start_client_hold(domain)
+          return if Rails.env.test?
+
+          STDOUT << "#{Time.zone.now.utc} DomainCron.start_client_hold: ##{domain.id} "\
+                    "(#{domain.name}) #{domain.changes}\n"
+        end
+
+        def log_end_end_client_hold(domain)
+          return if Rails.env.test?
+
+          STDOUT << "#{Time.zone.now.utc} - Successfully set client_hold on (#{domain.name})"
+        end
+      end
+    end
+  end
+end

app/models/concerns/job/force_delete_notify.rb

@@ -0,0 +1,30 @@
+module Concerns
+  module Job
+    module ForceDeleteNotify
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def notify_client_hold(domain)
+          domain.registrar.notifications.create!(text: I18n.t('client_hold_set_on_domain',
+                                                              domain_name: domain.name,
+                                                              date: domain.force_delete_start))
+        end
+
+        def notify_on_grace_period(domain)
+          domain.registrar.notifications.create!(text: I18n.t('grace_period_started_domain',
+                                                              domain_name: domain.name,
+                                                              date: domain.force_delete_start))
+          send_mail(domain)
+          domain.update(contact_notification_sent_date: Time.zone.today)
+        end
+
+        def send_mail(domain)
+          DomainDeleteMailer.forced(domain: domain,
+                                    registrar: domain.registrar,
+                                    registrant: domain.registrant,
+                                    template_name: domain.template_name).deliver_now
+        end
+      end
+    end
+  end
+end

app/models/domain.rb

@@ -547,6 +547,8 @@ class Domain < ApplicationRecord
       activate if nameservers.reject(&:marked_for_destruction?).size >= Setting.ns_min_count
     end
 
+    cancel_force_delete if force_delete_scheduled? && pending_json['new_registrant_id']
+
     if statuses.empty? && valid?
       statuses << DomainStatus::OK
     elsif (statuses.length > 1 && active?) || !valid?

app/models/domain_cron.rb

@@ -1,4 +1,7 @@
 class DomainCron
+  include Concerns::Job::ForceDelete
+  include Concerns::Job::ForceDeleteLogging
+  include Concerns::Job::ForceDeleteNotify
 
   def self.clean_expired_pendings
     STDOUT << "#{Time.zone.now.utc} - Clean expired domain pendings\n" unless Rails.env.test?

app/views/admin/domains/_force_delete_dialog.html.erb

@@ -10,6 +10,17 @@
 
             <%= form_tag admin_domain_force_delete_path(domain), id: 'domain-force-delete-form',
                          class: 'modal-body form-horizontal' do %>
+                <div class="form-group force-delete-type">
+                    <div class="col-md-9">
+                        <div class="checkbox">
+                            <label>
+                                <%= check_box_tag 'soft_delete', 1, true %>
+                                <%= t '.use_soft_delete' %>
+                            </label>
+                        </div>
+                    </div>
+                </div>
+
                 <div class="form-group">
                     <div class="col-md-9">
                         <div class="checkbox">

config/locales/admin/domains.en.yml

@@ -31,6 +31,7 @@ en:
       force_delete_dialog:
         title: Force delete
         notify_by_email: Notify registrant and administrative contacts by email
+        use_soft_delete: Use soft delete procedure
         email_template: Email template
         close_btn: Close dialog
         submit_btn: Force delete domain

config/locales/en.yml

@@ -619,6 +619,9 @@ en:
   created_at_until: 'Created at until'
   is_registrant: 'Is registrant'
   force_delete_set_on_domain: 'Force delete set on domain %{domain_name}'
+  client_hold_set_on_domain: 'clientHold status is set for domain %{domain_name}, ForceDelete is in effect from %{date}'
+  grace_period_started_domain: 'For domain %{domain_name} started 45-days redemption grace period, ForceDelete will be in effect from %{date}'
+  force_delete_cancelled: 'Force delete is cancelled on domain %{domain_name}'
   contact_is_not_valid: 'Contact %{value} is not valid, please fix the invalid contact'
   next: 'Next'
   previous: 'Previous'

config/schedule.rb

@@ -46,6 +46,10 @@ if @cron_group == 'registry'
     runner 'DomainCron.start_redemption_grace_period'
   end
 
+  every 1.day do
+    runner 'DomainCron.start_client_hold'
+  end
+
   every '0 0 1 * *' do
     runner 'Directo.send_monthly_invoices'
   end

db/migrate/20191203083643_add_force_delete_start_to_domains.rb

@@ -0,0 +1,5 @@
+class AddForceDeleteStartToDomains < ActiveRecord::Migration[5.0]
+  def change
+    add_column :domains, :force_delete_start, :datetime
+  end
+end

db/migrate/20200115102202_add_force_delete_data_to_domains.rb

@@ -0,0 +1,5 @@
+class AddForceDeleteDataToDomains < ActiveRecord::Migration[5.0]
+  def change
+    add_column :domains, :force_delete_data, :hstore
+  end
+end

db/structure.sql

@@ -8,6 +8,7 @@ SET client_encoding = 'UTF8';
 SET standard_conforming_strings = on;
 SELECT pg_catalog.set_config('search_path', '', false);
 SET check_function_bodies = false;
+SET xmloption = content;
 SET client_min_messages = warning;
 
 --
@@ -742,7 +743,10 @@ CREATE TABLE public.domains (
     upid integer,
     up_date timestamp without time zone,
     uuid uuid DEFAULT public.gen_random_uuid() NOT NULL,
-    locked_by_registrant_at timestamp without time zone
+    locked_by_registrant_at timestamp without time zone,
+    force_delete_start timestamp without time zone,
+    force_delete_data public.hstore
+
 );
 
 
@@ -4334,6 +4338,7 @@ INSERT INTO "schema_migrations" (version) VALUES
 ('20191206183853'),
 ('20191212133136'),
 ('20191227110904'),
-('20200113091254');
+('20200113091254'),
+('20200115102202');
 
 

test/models/domain/force_delete_test.rb

@@ -1,37 +1,70 @@
 require 'test_helper'
 
-class DomainForceDeleteTest < ActiveSupport::TestCase
+class NewDomainForceDeleteTest < ActiveSupport::TestCase
   setup do
     @domain = domains(:shop)
-    @original_redemption_grace_period = Setting.redemption_grace_period
-  end
-
-  teardown do
-    Setting.redemption_grace_period = @original_redemption_grace_period
-  end
-
-  def test_schedules_force_delete
-    assert_not @domain.force_delete_scheduled?
     Setting.redemption_grace_period = 30
+  end
+
+  def test_schedules_force_delete_fast_track
+    assert_not @domain.force_delete_scheduled?
     travel_to Time.zone.parse('2010-07-05')
 
-    @domain.schedule_force_delete
+    @domain.schedule_force_delete(type: :fast_track)
     @domain.reload
 
     assert @domain.force_delete_scheduled?
-    assert_equal Date.parse('2010-08-05'), @domain.force_delete_date
+    assert_equal Date.parse('2010-08-20'), @domain.force_delete_date.to_date
+    assert_equal Date.parse('2010-07-06'), @domain.force_delete_start.to_date
   end
 
-  def test_scheduling_force_delete_adds_corresponding_statuses
+  def test_schedules_force_delete_soft_year_ahead
+    @domain.update(valid_to: Time.zone.parse('2012-08-05'))
+    assert_not @domain.force_delete_scheduled?
+    travel_to Time.zone.parse('2010-07-05')
+
+    @domain.schedule_force_delete(type: :soft)
+    @domain.reload
+
+    assert @domain.force_delete_scheduled?
+    assert_equal Date.parse('2010-09-20'), @domain.force_delete_date.to_date
+    assert_equal Date.parse('2010-08-06'), @domain.force_delete_start.to_date
+  end
+
+  def test_schedules_force_delete_soft_less_than_year_ahead
+    @domain.update_columns(valid_to: Time.zone.parse('2010-08-05'),
+                           force_delete_date: nil)
+    assert_not @domain.force_delete_scheduled?
+    travel_to Time.zone.parse('2010-07-05')
+
+    @domain.schedule_force_delete(type: :soft)
+    @domain.reload
+
+    assert @domain.force_delete_scheduled?
+    assert_nil @domain.force_delete_date
+    assert_nil @domain.force_delete_start
+  end
+
+  def test_scheduling_soft_force_delete_adds_corresponding_statuses
     statuses_to_be_added = [
       DomainStatus::FORCE_DELETE,
       DomainStatus::SERVER_RENEW_PROHIBITED,
       DomainStatus::SERVER_TRANSFER_PROHIBITED,
-      DomainStatus::SERVER_UPDATE_PROHIBITED,
-      DomainStatus::PENDING_DELETE,
     ]
 
-    @domain.schedule_force_delete
+    @domain.schedule_force_delete(type: :soft)
+    @domain.reload
+    assert (@domain.statuses & statuses_to_be_added) == statuses_to_be_added
+  end
+
+  def test_scheduling_fast_track_force_delete_adds_corresponding_statuses
+    statuses_to_be_added = [
+      DomainStatus::FORCE_DELETE,
+      DomainStatus::SERVER_RENEW_PROHIBITED,
+      DomainStatus::SERVER_TRANSFER_PROHIBITED,
+    ]
+
+    @domain.schedule_force_delete(type: :fast_track)
     @domain.reload
     assert (@domain.statuses & statuses_to_be_added) == statuses_to_be_added
   end
@@ -43,12 +76,13 @@ class DomainForceDeleteTest < ActiveSupport::TestCase
     ]
 
     @domain.statuses = statuses_to_be_removed + %w[other-status]
-    @domain.schedule_force_delete
+    @domain.schedule_force_delete(type: :fast_track)
     @domain.reload
     assert_empty @domain.statuses & statuses_to_be_removed
   end
 
   def test_scheduling_force_delete_stops_pending_actions
+    Setting.redemption_grace_period = 45
     statuses_to_be_removed = [
       DomainStatus::PENDING_UPDATE,
       DomainStatus::PENDING_TRANSFER,
@@ -57,33 +91,35 @@ class DomainForceDeleteTest < ActiveSupport::TestCase
     ]
 
     @domain.statuses = statuses_to_be_removed + %w[other-status]
-    @domain.schedule_force_delete
+    @domain.schedule_force_delete(type: :fast_track)
     @domain.reload
     assert_empty @domain.statuses & statuses_to_be_removed, 'Pending actions should be stopped'
   end
 
   def test_scheduling_force_delete_preserves_current_statuses
     @domain.statuses = %w[test1 test2]
-    @domain.schedule_force_delete
+    @domain.schedule_force_delete(type: :fast_track)
     @domain.reload
     assert_equal %w[test1 test2], @domain.statuses_before_force_delete
   end
 
   def test_scheduling_force_delete_bypasses_validation
     @domain = domains(:invalid)
-    @domain.schedule_force_delete
+    @domain.schedule_force_delete(type: :fast_track)
     assert @domain.force_delete_scheduled?
   end
 
   def test_force_delete_cannot_be_scheduled_when_a_domain_is_discarded
     @domain.update!(statuses: [DomainStatus::DELETE_CANDIDATE])
     assert_raises StandardError do
-      @domain.schedule_force_delete
+      @domain.schedule_force_delete(type: :fast_track)
     end
   end
 
   def test_cancels_force_delete
-    @domain.update_columns(statuses: [DomainStatus::FORCE_DELETE], force_delete_date: '2010-07-05')
+    @domain.update_columns(statuses: [DomainStatus::FORCE_DELETE],
+                           force_delete_date: Time.zone.parse('2010-07-05'),
+                           force_delete_start: Time.zone.parse('2010-07-05') - 45.days)
     assert @domain.force_delete_scheduled?
 
     @domain.cancel_force_delete
@@ -91,11 +127,12 @@ class DomainForceDeleteTest < ActiveSupport::TestCase
 
     assert_not @domain.force_delete_scheduled?
     assert_nil @domain.force_delete_date
+    assert_nil @domain.force_delete_start
   end
 
   def test_cancelling_force_delete_bypasses_validation
     @domain = domains(:invalid)
-    @domain.schedule_force_delete
+    @domain.schedule_force_delete(type: :fast_track)
     @domain.cancel_force_delete
     assert_not @domain.force_delete_scheduled?
   end
@@ -105,12 +142,9 @@ class DomainForceDeleteTest < ActiveSupport::TestCase
       DomainStatus::FORCE_DELETE,
       DomainStatus::SERVER_RENEW_PROHIBITED,
       DomainStatus::SERVER_TRANSFER_PROHIBITED,
-      DomainStatus::SERVER_UPDATE_PROHIBITED,
-      DomainStatus::PENDING_DELETE,
-      DomainStatus::SERVER_MANUAL_INZONE
     ]
     @domain.statuses = @domain.statuses + statuses
-    @domain.schedule_force_delete
+    @domain.schedule_force_delete(type: :fast_track)
 
     @domain.cancel_force_delete
     @domain.reload
@@ -118,13 +152,65 @@ class DomainForceDeleteTest < ActiveSupport::TestCase
     assert_empty @domain.statuses & statuses
   end
 
-  def test_cancelling_force_delete_restores_statuses_that_a_domain_had_before_force_delete
-    @domain.statuses_before_force_delete = ['test1', DomainStatus::DELETE_CANDIDATE]
+  def test_force_delete_soft_year_ahead_sets_client_hold
+    asserted_status = DomainStatus::CLIENT_HOLD
 
-    @domain.cancel_force_delete
+    @domain.update(valid_to: Time.zone.parse('2012-08-05'))
+    @domain.update(template_name: 'legal_person')
+    assert_not @domain.force_delete_scheduled?
+    travel_to Time.zone.parse('2010-07-05')
+    @domain.schedule_force_delete(type: :soft)
+
+    travel_to Time.zone.parse('2010-08-21')
+    DomainCron.start_client_hold
+    @domain.reload
+    assert_includes(@domain.statuses, asserted_status)
+  end
+
+  def test_force_delete_soft_year_ahead_not_sets_client_hold_before_threshold
+    asserted_status = DomainStatus::CLIENT_HOLD
+
+    @domain.update_columns(valid_to: Time.zone.parse('2010-08-05'),
+                           force_delete_date: nil)
+    assert_not @domain.force_delete_scheduled?
+    travel_to Time.zone.parse('2010-07-05')
+    @domain.schedule_force_delete(type: :soft)
+
+    travel_to Time.zone.parse('2010-07-06')
+    DomainCron.start_client_hold
     @domain.reload
 
-    assert_equal ['test1', DomainStatus::DELETE_CANDIDATE], @domain.statuses
-    assert_nil @domain.statuses_before_force_delete
+    assert_not_includes(@domain.statuses, asserted_status)
+  end
+
+  def test_force_delete_fast_track_sets_client_hold
+    asserted_status = DomainStatus::CLIENT_HOLD
+    @domain.update_columns(valid_to: Time.zone.parse('2010-10-05'),
+                           force_delete_date: nil)
+
+    travel_to Time.zone.parse('2010-07-05')
+
+    @domain.schedule_force_delete(type: :fast_track)
+    travel_to Time.zone.parse('2010-07-25')
+    DomainCron.start_client_hold
+    @domain.reload
+
+    assert_includes(@domain.statuses, asserted_status)
+  end
+
+  def test_not_sets_hold_before_treshold
+    asserted_status = DomainStatus::CLIENT_HOLD
+    @domain.update_columns(valid_to: Time.zone.parse('2010-10-05'),
+                           force_delete_date: nil)
+    @domain.update(template_name: 'legal_person')
+
+    travel_to Time.zone.parse('2010-07-05')
+
+    @domain.schedule_force_delete(type: :fast_track)
+    travel_to Time.zone.parse('2010-07-06')
+    DomainCron.start_client_hold
+    @domain.reload
+
+    assert_not_includes(@domain.statuses, asserted_status)
   end
 end

test/models/domain_cron_test.rb

@@ -23,4 +23,19 @@ class DomainCronTest < ActiveSupport::TestCase
 
     assert_emails 1
   end
-end
+
+  def test_client_hold
+    Setting.redemption_grace_period = 30
+
+    @domain.update(valid_to: Time.zone.parse('2012-08-05'))
+    assert_not @domain.force_delete_scheduled?
+    travel_to Time.zone.parse('2010-07-05')
+    @domain.schedule_force_delete(type: :soft)
+    @domain.reload
+    @domain.update(template_name: 'legal_person')
+    travel_to Time.zone.parse('2010-08-06')
+    DomainCron.start_client_hold
+
+    assert_emails 1
+  end
+end

test/models/domain_test.rb

@@ -405,6 +405,22 @@ class DomainTest < ActiveSupport::TestCase
     assert_not domain.active?
   end
 
+  def test_registrant_change_removes_force_delete
+    @domain.update_columns(valid_to: Time.zone.parse('2010-10-05'),
+                           force_delete_date: nil)
+    @domain.update(template_name: 'legal_person')
+    travel_to Time.zone.parse('2010-07-05')
+    @domain.schedule_force_delete(type: :fast_track)
+    assert(@domain.force_delete_scheduled?)
+    other_registrant = Registrant.find_by(code: 'jane-001')
+    @domain.pending_json['new_registrant_id'] = other_registrant.id
+
+    @domain.registrant = other_registrant
+    @domain.save!
+
+    assert_not(@domain.force_delete_scheduled?)
+  end
+
   private
 
   def valid_domain

test/system/admin_area/domains/force_delete_test.rb

@@ -28,9 +28,18 @@ class AdminAreaDomainForceDeleteTest < ApplicationSystemTestCase
     end
   end
 
-  def test_notifies_registrant_and_admin_contacts_by_email_by_default
+  def test_notifies_registrant_and_admin_contacts_by_email_if_fast_delete
     assert_emails 1 do
       visit edit_admin_domain_url(@domain)
+      find(:css, '#soft_delete').set(false)
+      click_link_or_button 'Force delete domain'
+    end
+  end
+
+  def test_notifies_registrant_and_admin_contacts_by_email_if_soft_delete
+    assert_emails 0 do
+      visit edit_admin_domain_url(@domain)
+      find(:css, '#soft_delete').set(true)
       click_link_or_button 'Force delete domain'
     end
   end
@@ -62,4 +71,4 @@ class AdminAreaDomainForceDeleteTest < ApplicationSystemTestCase
     assert_no_button 'Schedule force delete'
     assert_no_link 'Schedule force delete'
   end
-end
+end