Extract code from Issues::MoveService

Extract code to make it easier reusable
- introduce AttributesRewriter and ContentRewriter
  - support group entites when rewriting content
- make Uploader copy_to working for Namespaces

1 files changed, 12 insertions, 256 deletions

diff --git a/spec/services/issues/move_service_spec.rb b/spec/services/issues/move_service_spec.rb
index b5767583952..1e088bc7d9b 100644
--- a/spec/services/issues/move_service_spec.rb
+++ b/spec/services/issues/move_service_spec.rb
@@ -10,11 +10,9 @@ describe Issues::MoveService do
   let(:sub_group_2) { create(:group, :private, parent: group) }
   let(:old_project) { create(:project, namespace: sub_group_1) }
   let(:new_project) { create(:project, namespace: sub_group_2) }
-  let(:milestone1) { create(:milestone, project_id: old_project.id, title: 'v9.0') }
 
   let(:old_issue) do
-    create(:issue, title: title, description: description,
-                   project: old_project, author: author, milestone: milestone1)
+    create(:issue, title: title, description: description, project: old_project, author: author)
   end
 
   subject(:move_service) do
@@ -25,16 +23,6 @@ describe Issues::MoveService do
     before do
       old_project.add_reporter(user)
       new_project.add_reporter(user)
-
-      labels = Array.new(2) { |x| "label%d" % (x + 1) }
-
-      labels.each do |label|
-        old_issue.labels << create(:label,
-          project_id: old_project.id,
-          title: label)
-
-        new_project.labels << create(:label, title: label)
-      end
     end
   end
 
@@ -48,91 +36,6 @@ describe Issues::MoveService do
     context 'issue movable' do
       include_context 'user can move issue'
 
-      context 'move to new milestone'  do
-        let(:new_issue) { move_service.execute(old_issue, new_project) }
-
-        context 'project milestone' do
-          let!(:milestone2) do
-            create(:milestone, project_id: new_project.id, title: 'v9.0')
-          end
-
-          it 'assigns milestone to new issue' do
-            expect(new_issue.reload.milestone.title).to eq 'v9.0'
-            expect(new_issue.reload.milestone).to eq(milestone2)
-          end
-        end
-
-        context 'group milestones' do
-          let!(:group) { create(:group, :private) }
-          let!(:group_milestone_1) do
-            create(:milestone, group_id: group.id, title: 'v9.0_group')
-          end
-
-          before do
-            old_issue.update(milestone: group_milestone_1)
-            old_project.update(namespace: group)
-            new_project.update(namespace: group)
-
-            group.add_users([user], GroupMember::DEVELOPER)
-          end
-
-          context 'when moving to a project of the same group' do
-            it 'keeps the same group milestone' do
-              expect(new_issue.reload.project).to eq(new_project)
-              expect(new_issue.reload.milestone).to eq(group_milestone_1)
-            end
-          end
-
-          context 'when moving to a project of a different group' do
-            let!(:group_2) { create(:group, :private) }
-
-            let!(:group_milestone_2) do
-              create(:milestone, group_id: group_2.id, title: 'v9.0_group')
-            end
-
-            before do
-              old_issue.update(milestone: group_milestone_1)
-              new_project.update(namespace: group_2)
-
-              group_2.add_users([user], GroupMember::DEVELOPER)
-            end
-
-            it 'assigns to new group milestone of same title' do
-              expect(new_issue.reload.project).to eq(new_project)
-              expect(new_issue.reload.milestone).to eq(group_milestone_2)
-            end
-          end
-        end
-      end
-
-      context 'issue with group labels', :nested_groups do
-        it 'assigns group labels to new issue' do
-          label = create(:group_label, group: group)
-          label_issue = create(:labeled_issue, description: description, project: old_project,
-                                               milestone: milestone1, labels: [label])
-          old_project.add_reporter(user)
-          new_project.add_reporter(user)
-
-          new_issue = move_service.execute(label_issue, new_project)
-
-          expect(new_issue).to have_attributes(
-            project: new_project,
-            labels: include(label)
-          )
-        end
-      end
-
-      context 'issue with resource label events' do
-        it 'assigns resource label events to new issue' do
-          old_issue.resource_label_events = create_list(:resource_label_event, 2, issue: old_issue)
-
-          new_issue = move_service.execute(old_issue, new_project)
-
-          expected = old_issue.resource_label_events.map(&:label_id)
-          expect(new_issue.resource_label_events.map(&:label_id)).to match_array(expected)
-        end
-      end
-
       context 'generic issue' do
         include_context 'issue move executed'
 
@@ -140,18 +43,6 @@ describe Issues::MoveService do
           expect(new_issue.project).to eq new_project
         end
 
-        it 'assign labels to new issue' do
-          expected_label_titles = new_issue.reload.labels.map(&:title)
-          expect(expected_label_titles).to include 'label1'
-          expect(expected_label_titles).to include 'label2'
-          expect(expected_label_titles.size).to eq 2
-
-          new_issue.labels.each do |label|
-            expect(new_project.labels).to include(label)
-            expect(old_project.labels).not_to include(label)
-          end
-        end
-
         it 'rewrites issue title' do
           expect(new_issue.title).to eq title
         end
@@ -203,140 +94,25 @@ describe Issues::MoveService do
         end
       end
 
-      context 'issue with notes' do
-        context 'notes without references' do
-          let(:notes_params) do
-            [{ system: false, note: 'Some comment 1' },
-             { system: true, note: 'Some system note' },
-             { system: false, note: 'Some comment 2' }]
-          end
-          let(:award_names) { %w(thumbsup thumbsdown facepalm) }
-          let(:notes_contents) { notes_params.map { |n| n[:note] } }
-
-          before do
-            note_params = { noteable: old_issue, project: old_project, author: author }
-            notes_params.each_with_index do |note, index|
-              new_note = create(:note, note_params.merge(note))
-              award_emoji_params = { awardable: new_note, name: award_names[index] }
-              create(:award_emoji, award_emoji_params)
-            end
-          end
-
-          include_context 'issue move executed'
-
-          let(:all_notes) { new_issue.notes.order('id ASC') }
-          let(:system_notes) { all_notes.system }
-          let(:user_notes) { all_notes.user }
-
-          it 'rewrites existing notes in valid order' do
-            expect(all_notes.pluck(:note).first(3)).to eq notes_contents
-          end
-
-          it 'creates new emojis for the new notes' do
-            expect(all_notes.map(&:award_emoji).to_a.flatten.map(&:name)).to eq award_names
-          end
-
-          it 'adds a system note about move after rewritten notes' do
-            expect(system_notes.last.note).to match /^moved from/
-          end
-
-          it 'preserves orignal author of comment' do
-            expect(user_notes.pluck(:author_id)).to all(eq(author.id))
-          end
-        end
-
-        context 'note that has been updated' do
-          let!(:note) do
-            create(:note, noteable: old_issue, project: old_project,
-                          author: author, updated_at: Date.yesterday,
-                          created_at: Date.yesterday)
-          end
-
-          include_context 'issue move executed'
-
-          it 'preserves time when note has been created at' do
-            expect(new_issue.notes.first.created_at).to eq note.created_at
-          end
+      context 'issue with assignee' do
+        let(:assignee) { create(:user) }
 
-          it 'preserves time when note has been updated at' do
-            expect(new_issue.notes.first.updated_at).to eq note.updated_at
-          end
-        end
-
-        context 'issue with assignee' do
-          let(:assignee) { create(:user) }
-
-          before do
-            old_issue.assignees = [assignee]
-          end
-
-          it 'preserves assignee with access to the new issue' do
-            new_project.add_reporter(assignee)
-
-            new_issue = move_service.execute(old_issue, new_project)
-
-            expect(new_issue.assignees).to eq([assignee])
-          end
-
-          it 'ignores assignee without access to the new issue' do
-            new_issue = move_service.execute(old_issue, new_project)
-
-            expect(new_issue.assignees).to be_empty
-          end
-        end
-
-        context 'notes with references' do
-          before do
-            create(:merge_request, source_project: old_project)
-            create(:note, noteable: old_issue, project: old_project, author: author,
-                          note: 'Note with reference to merge request !1')
-          end
-
-          include_context 'issue move executed'
-          let(:new_note) { new_issue.notes.first }
-
-          it 'rewrites references using a cross reference to old project' do
-            expect(new_note.note)
-              .to eq "Note with reference to merge request #{old_project.to_reference(new_project)}!1"
-          end
-        end
-
-        context 'issue description with uploads' do
-          let(:uploader) { build(:file_uploader, project: old_project) }
-          let(:description) { "Text and #{uploader.markdown_link}" }
-
-          include_context 'issue move executed'
-
-          it 'rewrites uploads in description' do
-            expect(new_issue.description).not_to eq description
-            expect(new_issue.description)
-              .to match(/Text and #{FileUploader::MARKDOWN_PATTERN}/)
-            expect(new_issue.description).not_to include uploader.secret
-          end
+        before do
+          old_issue.assignees = [assignee]
         end
-      end
 
-      describe 'rewriting references' do
-        include_context 'issue move executed'
+        it 'preserves assignee with access to the new issue' do
+          new_project.add_reporter(assignee)
 
-        context 'issue references' do
-          let(:another_issue) { create(:issue, project: old_project) }
-          let(:description) { "Some description #{another_issue.to_reference}" }
+          new_issue = move_service.execute(old_issue, new_project)
 
-          it 'rewrites referenced issues creating cross project reference' do
-            expect(new_issue.description)
-              .to eq "Some description #{another_issue.to_reference(new_project)}"
-          end
+          expect(new_issue.assignees).to eq([assignee])
         end
 
-        context "user references" do
-          let(:another_issue) { create(:issue, project: old_project) }
-          let(:description) { "Some description #{user.to_reference}" }
+        it 'ignores assignee without access to the new issue' do
+          new_issue = move_service.execute(old_issue, new_project)
 
-          it "doesn't throw any errors for issues containing user references" do
-            expect(new_issue.description)
-              .to eq "Some description #{user.to_reference}"
-          end
+          expect(new_issue.assignees).to be_empty
         end
       end
 
@@ -416,25 +192,5 @@ describe Issues::MoveService do
         it { expect { move }.to raise_error(StandardError, /permissions/) }
       end
     end
-
-    context 'movable issue with no assigned labels' do
-      before do
-        old_project.add_reporter(user)
-        new_project.add_reporter(user)
-
-        labels = Array.new(2) { |x| "label%d" % (x + 1) }
-
-        labels.each do |label|
-          new_project.labels << create(:label, title: label)
-        end
-      end
-
-      include_context 'issue move executed'
-
-      it 'does not assign labels to new issue' do
-        expected_label_titles = new_issue.reload.labels.map(&:title)
-        expect(expected_label_titles.size).to eq 0
-      end
-    end
   end
 end