Merge pull request #1741 from internetee/1740-interactor-force-delete

Refactor ForceDelete procedure to use interactor design pattern

Gemfile

@@ -1,6 +1,7 @@
 source 'https://rubygems.org'
 
 # core
+gem 'active_interaction', '~> 3.8'
 gem 'bootsnap', '>= 1.1.0', require: false
 gem 'iso8601', '0.12.1' # for dates and times
 gem 'rails', '~> 6.0'

Gemfile.lock

@@ -112,6 +112,8 @@ GEM
       erubi (~> 1.4)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    active_interaction (3.8.3)
+      activemodel (>= 4, < 7)
     activejob (6.0.3.3)
       activesupport (= 6.0.3.3)
       globalid (>= 0.3.6)
@@ -521,6 +523,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  active_interaction (~> 3.8)
   activerecord-import
   airbrake
   bootsnap (>= 1.1.0)

app/controllers/admin/domains/force_delete_controller.rb

@@ -4,26 +4,15 @@ module Admin
       def create
         authorize! :manage, domain
 
+        notice = t('.scheduled')
+
         domain.transaction do
-          domain.schedule_force_delete(type: force_delete_type)
-          domain.registrar.notifications.create!(text: t('force_delete_set_on_domain',
-                                                         domain_name: domain.name,
-                                                         outzone_date: domain.outzone_date,
-                                                         purge_date: domain.purge_date))
-
-          notify_by_email if notify_by_email?
+          result = domain.schedule_force_delete(type: force_delete_type,
+                                                notify_by_email: notify_by_email?)
+          notice = result.errors.messages[:domain].first unless result.valid?
         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: domain.notification_template)
-        end
+        redirect_to edit_admin_domain_url(domain), notice: notice
       end
 
       def destroy
@@ -42,13 +31,6 @@ module Admin
         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: domain.notification_template).deliver_now
-      end
-
       def force_delete_type
         soft_delete? ? :soft : :fast_track
       end

app/interactions/force_delete_interaction/base.rb

@@ -0,0 +1,16 @@
+module ForceDeleteInteraction
+  class Base < ActiveInteraction::Base
+    object :domain,
+           class: Domain,
+           description: 'Domain to set ForceDelete on'
+    symbol :type,
+           default: :fast_track,
+           description: 'Force delete type, might be :fast_track or :soft'
+    boolean :notify_by_email,
+            default: false,
+            description: 'Do we need to send email notification'
+
+    validates :type, inclusion: { in: %i[fast_track soft] }
+  end
+end
+

app/interactions/force_delete_interaction/check_discarded.rb

@@ -0,0 +1,11 @@
+module ForceDeleteInteraction
+  class CheckDiscarded < Base
+    def execute
+      return true unless domain.discarded?
+
+      message = 'Force delete procedure cannot be scheduled while a domain is discarded'
+      errors.add(:domain, message)
+    end
+  end
+end
+

app/interactions/force_delete_interaction/notify_by_email.rb

@@ -0,0 +1,21 @@
+module ForceDeleteInteraction
+  class NotifyByEmail < Base
+    def execute
+      return unless notify_by_email
+
+      if type == :fast_track
+        send_email
+        domain.update(contact_notification_sent_date: Time.zone.today)
+      else
+        domain.update(template_name: domain.notification_template)
+      end
+    end
+
+    def send_email
+      DomainDeleteMailer.forced(domain: domain,
+                                registrar: domain.registrar,
+                                registrant: domain.registrant,
+                                template_name: domain.notification_template).deliver_now
+    end
+  end
+end

app/interactions/force_delete_interaction/notify_registrar.rb

@@ -0,0 +1,10 @@
+module ForceDeleteInteraction
+  class NotifyRegistrar < Base
+    def execute
+      domain.registrar.notifications.create!(text: I18n.t('force_delete_set_on_domain',
+                                                          domain_name: domain.name,
+                                                          outzone_date: domain.outzone_date,
+                                                          purge_date: domain.purge_date))
+    end
+  end
+end

app/interactions/force_delete_interaction/post_set_process.rb

@@ -0,0 +1,17 @@
+module ForceDeleteInteraction
+  class PostSetProcess < Base
+    def execute
+      statuses = domain.statuses
+      # Stop all pending actions
+      statuses.delete(DomainStatus::PENDING_UPDATE)
+      statuses.delete(DomainStatus::PENDING_TRANSFER)
+      statuses.delete(DomainStatus::PENDING_RENEW)
+      statuses.delete(DomainStatus::PENDING_CREATE)
+
+      # Allow deletion
+      statuses.delete(DomainStatus::CLIENT_DELETE_PROHIBITED)
+      statuses.delete(DomainStatus::SERVER_DELETE_PROHIBITED)
+      domain.save(validate: false)
+    end
+  end
+end

app/interactions/force_delete_interaction/prepare_domain.rb

@@ -0,0 +1,13 @@
+module ForceDeleteInteraction
+  class PrepareDomain < Base
+    STATUSES_TO_SET = [DomainStatus::FORCE_DELETE,
+                       DomainStatus::SERVER_RENEW_PROHIBITED,
+                       DomainStatus::SERVER_TRANSFER_PROHIBITED].freeze
+
+    def execute
+      domain.statuses_before_force_delete = domain.statuses
+      domain.statuses |= STATUSES_TO_SET
+      domain.save(validate: false)
+    end
+  end
+end

app/interactions/force_delete_interaction/set_force_delete.rb

@@ -0,0 +1,12 @@
+module ForceDeleteInteraction
+  class SetForceDelete < Base
+    def execute
+      compose(CheckDiscarded, inputs)
+      compose(PrepareDomain, inputs)
+      compose(SetStatus, inputs)
+      compose(PostSetProcess, inputs)
+      compose(NotifyRegistrar, inputs)
+      compose(NotifyByEmail, inputs)
+    end
+  end
+end

app/interactions/force_delete_interaction/set_status.rb

@@ -0,0 +1,38 @@
+module ForceDeleteInteraction
+  class SetStatus < Base
+    def execute
+      domain.force_delete_type = type
+      type == :fast_track ? force_delete_fast_track : force_delete_soft
+      domain.save(validate: false)
+    end
+
+    def force_delete_fast_track
+      domain.force_delete_date = Time.zone.today +
+                                 expire_warning_period_days +
+                                 redemption_grace_period_days
+      domain.force_delete_start = Time.zone.today + 1.day
+    end
+
+    def force_delete_soft
+      years = (domain.valid_to.to_date - Time.zone.today).to_i / 365
+      soft_forcedelete_dates(years) if years.positive?
+    end
+
+    private
+
+    def soft_forcedelete_dates(years)
+      domain.force_delete_start = domain.valid_to - years.years
+      domain.force_delete_date = domain.force_delete_start +
+                                 Setting.expire_warning_period.days +
+                                 Setting.redemption_grace_period.days
+    end
+
+    def redemption_grace_period_days
+      Setting.redemption_grace_period.days + 1.day
+    end
+
+    def expire_warning_period_days
+      Setting.expire_warning_period.days
+    end
+  end
+end

app/models/concerns/domain/force_delete.rb

@@ -52,37 +52,10 @@ module Concerns::Domain::ForceDelete # rubocop:disable Metrics/ModuleLength
     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
-    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 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)
+  def schedule_force_delete(type: :fast_track, notify_by_email: false)
+    ForceDeleteInteraction::SetForceDelete.run(domain: self,
+                                               type: type,
+                                               notify_by_email: notify_by_email)
   end
 
   def clear_force_delete_data
@@ -110,52 +83,15 @@ module Concerns::Domain::ForceDelete # rubocop:disable Metrics/ModuleLength
 
   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
-    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)
-    statuses.delete(DomainStatus::PENDING_RENEW)
-    statuses.delete(DomainStatus::PENDING_CREATE)
-  end
-
-  def preserve_current_statuses_for_force_delete
-    update(statuses_before_force_delete: statuses)
-  end
-
   def restore_statuses_before_force_delete
     self.statuses = statuses_before_force_delete
     self.statuses_before_force_delete = nil
   end
 
-  def add_force_delete_statuses
-    self.statuses |= [DomainStatus::FORCE_DELETE,
-                      DomainStatus::SERVER_RENEW_PROHIBITED,
-                      DomainStatus::SERVER_TRANSFER_PROHIBITED]
-  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::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

config/application.rb

@@ -36,6 +36,7 @@ module DomainNameRegistry
 
     # Autoload all model subdirs
     config.autoload_paths += Dir[Rails.root.join('app', 'models', '**/')]
+    config.autoload_paths += Dir[Rails.root.join('app', 'interactions', '**/')]
     config.eager_load_paths << config.root.join('lib', 'validators')
     config.watchable_dirs['lib'] = %i[rb]
 

test/models/domain/force_delete_test.rb

@@ -1,18 +1,20 @@
 require 'test_helper'
 
-class NewDomainForceDeleteTest < ActiveSupport::TestCase
+class ForceDeleteTest < ActionMailer::TestCase
   setup do
     @domain = domains(:shop)
     Setting.redemption_grace_period = 30
+    ActionMailer::Base.deliveries.clear
   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(type: :fast_track)
+    @domain.schedule_force_delete(type: :fast_track, notify_by_email: true)
     @domain.reload
 
+    assert_emails 1
     assert @domain.force_delete_scheduled?
     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
@@ -111,9 +113,12 @@ class NewDomainForceDeleteTest < ActiveSupport::TestCase
 
   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(type: :fast_track)
-    end
+    result = ForceDeleteInteraction::SetForceDelete.run(domain: @domain, type: :fast_track)
+
+    assert_not result.valid?
+    assert_not @domain.force_delete_scheduled?
+    message = ["Force delete procedure cannot be scheduled while a domain is discarded"]
+    assert_equal message, result.errors.messages[:domain]
   end
 
   def test_cancels_force_delete

test/models/domain_test.rb

@@ -414,7 +414,7 @@ class DomainTest < ActiveSupport::TestCase
                            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)
+    ForceDeleteInteraction::SetForceDelete.run!(domain: @domain, 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