Skip issue workers when creating a synced work item

app/services/issues/create_service.rb

@@ -49,15 +49,8 @@ def external_author
     def before_create(issue)
       issue.check_for_spam(user: current_user, action: :create) if perform_spam_check
 
-      # current_user (defined in BaseService) is not available within run_after_commit block
-      user = current_user
       assign_description_from_template(issue)
-      issue.run_after_commit do
-        NewIssueWorker.perform_async(issue.id, user.id, issue.class.to_s)
-        Issues::PlacementWorker.perform_async(nil, issue.project_id)
-        # issue.namespace_id can point to either a project through project namespace or a group.
-        Onboarding::IssueCreatedWorker.perform_async(issue.namespace_id)
-      end
+      after_commit_tasks(current_user, issue)
     end
 
     # Add new items to Issues::AfterCreateService if they can be performed in Sidekiq
@@ -160,6 +153,15 @@ def assign_description_from_template(issue)
 
       issue.description = default_template.content if default_template.present?
     end
+
+    def after_commit_tasks(user, issue)
+      issue.run_after_commit do
+        NewIssueWorker.perform_async(issue.id, user.id, issue.class.to_s)
+        Issues::PlacementWorker.perform_async(nil, issue.project_id)
+        # issue.namespace_id can point to either a project through project namespace or a group.
+        Onboarding::IssueCreatedWorker.perform_async(issue.namespace_id)
+      end
+    end
   end
 end
 

app/services/work_items/create_service.rb

@@ -16,8 +16,8 @@ def initialize(container:, perform_spam_check: true, current_user: nil, params:
       @widget_params = widget_params
     end
 
-    def execute
-      result = super
+    def execute(skip_system_notes: false)
+      result = skip_system_notes? ? super(skip_system_notes: true) : super
       return result if result.error?
 
       work_item = result[:issue]
@@ -86,6 +86,10 @@ def authorization_action
     def payload(work_item)
       { work_item: work_item }
     end
+
+    def skip_system_notes?
+      false
+    end
   end
 end
 

ee/app/services/ee/work_items/create_service.rb

@@ -9,16 +9,33 @@ module CreateService
 
       override :iid_param_allowed?
       def iid_param_allowed?
-        # Used when creating a new epic with a synced work item
-        extra_params&.fetch(:synced_work_item, false) || super
+        sync_work_item? || super
       end
 
       override :filter_timestamp_params
       def filter_timestamp_params
-        return if extra_params&.fetch(:synced_work_item, false)
+        return if sync_work_item?
 
         super
       end
+
+      override :skip_system_notes?
+      def skip_system_notes?
+        return true if sync_work_item?
+
+        super
+      end
+
+      override :after_commit_tasks
+      def after_commit_tasks(user, work_item)
+        return if sync_work_item?
+
+        super
+      end
+
+      def sync_work_item?
+        extra_params&.fetch(:synced_work_item, false)
+      end
     end
   end
 end

ee/spec/services/epics/create_service_spec.rb

@@ -82,6 +82,35 @@
         let(:epic) { Epic.last }
       end
 
+      it 'does not create work item metrics' do
+        expect { subject }.to change { Epic.count }.by(1)
+          .and(change { WorkItem.count }.by(1))
+          .and(not_change { Issue::Metrics.count })
+      end
+
+      it 'does not duplicate system notes' do
+        expect { subject }.to change { Epic.count }.by(1).and(change { WorkItem.count }.by(1))
+
+        expect(Epic.last.notes.size).to eq(1)
+        expect(WorkItem.last.notes.size).to eq(0)
+      end
+
+      it 'does not call run_after_commit for the work item' do
+        expect_next_instance_of(WorkItem) do |instance|
+          expect(instance).not_to receive(:run_after_commit)
+        end
+
+        subject
+      end
+
+      it 'does not call after commit workers for the work item' do
+        expect(NewIssueWorker).not_to receive(:perform_async)
+        expect(Issues::PlacementWorker).not_to receive(:perform_async)
+        expect(Onboarding::IssueCreatedWorker).not_to receive(:perform_async)
+
+        subject
+      end
+
       context 'when work item creation fails' do
         it 'does not create epic' do
           error_msg = 'error 1, error 2'

ee/spec/services/work_items/create_service_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe WorkItems::CreateService, feature_category: :team_planning do
+  let_it_be(:developer) { create(:user) }
+  let_it_be(:group) { create(:group).tap { |group| group.add_developer(developer) } }
+  let_it_be(:work_item_type) { create(:work_item_type, :epic, namespace: group) }
+
+  let(:current_user) { developer }
+  let(:extra_params) { {} }
+  let(:widget_params) { {} }
+  let(:params) do
+    {
+      work_item_type: work_item_type,
+      title: 'Awesome work_item',
+      description: 'please fix',
+      confidential: true
+    }
+  end
+
+  describe '#execute' do
+    let(:service) do
+      described_class.new(
+        container: group,
+        current_user: current_user,
+        params: params.merge(extra_params),
+        widget_params: widget_params
+      )
+    end
+
+    subject(:create_work_item) { service.execute }
+
+    before do
+      stub_licensed_features(epics: true)
+    end
+
+    context 'when params are valid' do
+      it 'created instance is a WorkItem' do
+        expect(Issuable::CommonSystemNotesService).to receive_message_chain(:new, :execute)
+
+        work_item = create_work_item[:work_item]
+
+        expect(work_item).to be_persisted
+        expect(work_item).to be_a(::WorkItem)
+        expect(work_item.title).to eq('Awesome work_item')
+        expect(work_item.description).to eq('please fix')
+        expect(work_item.confidential).to eq(true)
+        expect(work_item.work_item_type.base_type).to eq('epic')
+      end
+
+      it 'calls NewIssueWorker with correct arguments' do
+        expect(NewIssueWorker).to receive(:perform_async)
+          .with(Integer, current_user.id, 'WorkItem')
+
+        create_work_item
+      end
+
+      context 'when synced_work_item is true' do
+        let(:extra_params) { { extra_params: { synced_work_item: true } } }
+
+        it 'does not call system notes service' do
+          expect(Issuable::CommonSystemNotesService).not_to receive(:new)
+
+          work_item = create_work_item[:work_item]
+
+          expect(work_item).to be_persisted
+          expect(work_item).to be_a(::WorkItem)
+        end
+
+        it 'does not call after commit workers' do
+          expect(NewIssueWorker).not_to receive(:perform_async)
+          expect(Issues::PlacementWorker).not_to receive(:perform_async)
+          expect(Onboarding::IssueCreatedWorker).not_to receive(:perform_async)
+
+          create_work_item
+        end
+      end
+    end
+  end
+end