ticket-replicator 1.0.0 → 1.2.0

data/spec/ticket/replicator/row_loader_spec.rb

@@ -20,12 +20,13 @@ module Ticket
       end
 
       describe ".fields_to_load" do
-        it { expect(described_class.fields_to_load).to eq(%i[id status resolution priority summary]) }
+        it { expect(described_class.fields_to_load).to eq(%i[id status resolution priority summary source_ticket_url]) }
       end
 
       describe "#run" do
         it do
           expect(loader).to receive(:save_ticket)
+          expect(loader).to receive(:update_source_ticket_remote_link)
           expect(loader).to receive(:transition_ticket_to_the_expected_status)
 
           loader.run
@@ -41,7 +42,7 @@ module Ticket
           it do
             expect(loader).to receive(:create_ticket)
 
-            loader.ticket
+            loader.send(:ticket)
           end
         end
 
@@ -51,7 +52,7 @@ module Ticket
           it do
             expect(loader).to receive(:fetch_ticket)
 
-            loader.ticket
+            loader.send(:ticket)
           end
         end
       end
@@ -107,7 +108,7 @@ module Ticket
         it do
           expect(jira_project).to receive(:replicated_tickets).and_return(replicated_tickets)
 
-          expect(loader.fetch_ticket).to be(:a_ticket)
+          expect(loader.send(:fetch_ticket)).to be(:a_ticket)
         end
       end
 
@@ -127,7 +128,7 @@ module Ticket
           expect(issue_accessor).to receive(:build).and_return(jira_ticket)
           expect(Ticket).to receive(:new).with(jira_auto_tool, jira_ticket).and_return(:ticket)
 
-          expect(loader.create_ticket).to eq(:ticket)
+          expect(loader.send(:create_ticket)).to eq(:ticket)
         end
       end
 
@@ -148,26 +149,14 @@ module Ticket
             ticket: ticket,
             :ticket_fields_need_to_be_updated? => ticket_fields_need_to_be_updated?
           )
-
-          allow(jira_project)
-            .to receive_messages(resolutions: {
-                                   "Done" => nil, "Won't Do" => nil, "Duplicate" => nil, "Cannot Reproduce" => nil
-                                 })
         end
 
         context "when the previously replicated needs to be updated " do
           let(:ticket_fields_need_to_be_updated?) { true }
 
           it do
-            expect(jira_ticket).to receive(:save!).with({
-                                                          fields: {
-                                                            project: { key: "PROJKEY" },
-                                                            issuetype: { name: "Bug" },
-                                                            resolution: { name: "Done" },
-                                                            priority: { name: "Low" },
-                                                            summary: "PREFIX | summary"
-                                                          }
-                                                        })
+            allow(loader).to receive_messages(attributes_for_save: { fields: { a: "b" } })
+            expect(jira_ticket).to receive(:save!).with({ fields: { a: "b" } })
 
             expect(jira_ticket).to receive(:fetch)
 
@@ -187,6 +176,95 @@ module Ticket
         end
       end
 
+      describe "#attributes_for_save" do
+        let(:loader) { described_class.send(:new, jira_project, row) }
+
+        let(:row) do
+          { id: "123", priority: "Low", resolution: "Done", status: "Open", summary: "PREFIX | summary",
+            team: "A Team" }
+        end
+
+        before do
+          allow(jira_project)
+            .to receive_messages(resolutions: {
+                                   "Done" => nil, "Won't Do" => nil, "Duplicate" => nil, "Cannot Reproduce" => nil
+                                 })
+
+          allow(loader).to receive_messages(exclude_resolution?: exclude_resolution?)
+        end
+
+        context "when the resolution is not excluded" do
+          let(:exclude_resolution?) { false }
+
+          it do
+            expect(loader.send(:attributes_for_save)).to eq({
+                                                              fields: {
+                                                                project: { key: "PROJKEY" },
+                                                                issuetype: { name: "Bug" },
+                                                                priority: { name: "Low" },
+                                                                resolution: { name: "Done" },
+                                                                summary: "PREFIX | summary"
+                                                              }
+                                                            })
+          end
+        end
+
+        context "when excluding the resolution" do
+          let(:exclude_resolution?) { true }
+
+          it do
+            expect(loader.send(:attributes_for_save)).to eq({
+                                                              fields: {
+                                                                project: { key: "PROJKEY" },
+                                                                issuetype: { name: "Bug" },
+                                                                priority: { name: "Low" },
+                                                                summary: "PREFIX | summary"
+                                                              }
+                                                            })
+          end
+        end
+      end
+
+      describe "#exclude_resolution?" do
+        before { allow(ENV).to receive(:[]).with("TICKET_REPLICATOR_DISABLE_RESOLUTION_LOADING").and_return(env_value) }
+
+        context "when the environment variable is not set to true" do
+          let(:env_value) { nil }
+
+          it { expect(loader.send(:exclude_resolution?)).to be_falsey }
+        end
+
+        context "when the environment variable is set to true" do
+          let(:env_value) { "true" }
+
+          it { expect(loader.send(:exclude_resolution?)).to be_truthy }
+        end
+      end
+
+      describe "#build_ticket_link_attributes" do
+        it "builds the link attributes with a default application" do
+          expect(described_class.send(:build_ticket_link_attributes,
+                                      "https://url/to/source/ticket/123", "Source Ticket 123"))
+            .to eq({ "object" => { "url" => "https://url/to/source/ticket/123", "title" => "Source Ticket 123" },
+                     "application" => { "name" => "Ticket Source" } })
+        end
+
+        it "builds the link attributes with a custom application" do
+          expect(described_class.send(:build_ticket_link_attributes,
+                                      "https://url/to/source/ticket/123", "Source Ticket 123",
+                                      "A custom application"))
+            .to eq({ "object" => { "url" => "https://url/to/source/ticket/123", "title" => "Source Ticket 123" },
+                     "application" => { "name" => "A custom application" } })
+        end
+
+        it "builds the link attributes with no application" do
+          expect(described_class.send(:build_ticket_link_attributes,
+                                      "https://url/to/source/ticket/123", "Source Ticket 123",
+                                      nil))
+            .to eq({ "object" => { "url" => "https://url/to/source/ticket/123", "title" => "Source Ticket 123" } })
+        end
+      end
+
       describe "#ticket_fields_need_to_be_updated?" do
         before do
           allow(loader).to receive_messages(ticket_previously_replicated?: ticket_previously_replicated?,
@@ -197,21 +275,21 @@ module Ticket
           let(:ticket_previously_replicated?) { false }
           let(:ticket_fields_changed?) { false }
 
-          it { expect(loader.ticket_fields_need_to_be_updated?).to be_truthy }
+          it { expect(loader.send(:ticket_fields_need_to_be_updated?)).to be_truthy }
         end
 
         context "when the fields changed since last replication" do
           let(:ticket_previously_replicated?) { true }
           let(:ticket_fields_changed?) { true }
 
-          it { expect(loader.ticket_fields_need_to_be_updated?).to be_truthy }
+          it { expect(loader.send(:ticket_fields_need_to_be_updated?)).to be_truthy }
         end
 
         context "when the fields did not change since last replication" do
           let(:ticket_previously_replicated?) { true }
           let(:ticket_fields_changed?) { false }
 
-          it { expect(loader.ticket_fields_need_to_be_updated?).to be_falsey }
+          it { expect(loader.send(:ticket_fields_need_to_be_updated?)).to be_falsey }
         end
       end
 
@@ -221,75 +299,227 @@ module Ticket
         end
 
         let(:loader) { described_class.send(:new, jira_project, row) }
-        let(:jira_ticket) { double(JIRA::Resource::Issue, summary: current_summary, priority: current_priority) }
+
+        let(:jira_ticket) do
+          double(JIRA::Resource::Issue,
+                 summary: current_summary,
+                 priority: current_priority,
+                 resolution: current_resolution)
+        end
 
         before do
           expect(loader).to receive(:ticket).at_least(:once).and_return(jira_ticket)
         end
 
-        context "when both summary and priority changed" do
+        context "when summary, priority and resolution changed" do
           let(:current_summary) { "PREFIX | different summary" }
           let(:current_priority) { "High" }
+          let(:current_resolution) { "Won't Do" }
 
-          it { expect(loader.ticket_fields_changed?).to be_truthy }
+          it { expect(loader.send(:ticket_fields_changed?)).to be_truthy }
         end
 
         context "when only summary changed" do
           let(:current_summary) { "PREFIX | different summary" }
           let(:current_priority) { "Low" }
+          let(:current_resolution) { "" }
 
-          it { expect(loader.ticket_fields_changed?).to be_truthy }
+          it { expect(loader.send(:ticket_fields_changed?)).to be_truthy }
         end
 
         context "when only priority changed" do
           let(:current_summary) { "PREFIX | summary" }
           let(:current_priority) { "High" }
+          let(:current_resolution) { "" }
 
-          it { expect(loader.ticket_fields_changed?).to be_truthy }
+          it { expect(loader.send(:ticket_fields_changed?)).to be_truthy }
+        end
+
+        context "when only resolution changed" do
+          let(:current_summary) { "PREFIX | summary" }
+          let(:current_priority) { "Low" }
+          let(:current_resolution) { "Done" }
+
+          before do
+            allow(loader).to receive_messages(exclude_resolution?: exclude_resolution?)
+          end
+
+          context "when the resolution is not excluded" do
+            let(:exclude_resolution?) { false }
+
+            it { expect(loader.send(:ticket_fields_changed?)).to be_truthy }
+          end
+
+          context "when excluding the resolution" do
+            let(:exclude_resolution?) { true }
+
+            it { expect(loader.send(:ticket_fields_changed?)).to be_falsey }
+          end
         end
 
         context "when neither summary nor priority changed" do
           let(:current_summary) { "PREFIX | summary" }
           let(:current_priority) { "Low" }
+          let(:current_resolution) { "" }
 
-          it { expect(loader.ticket_fields_changed?).to be_falsey }
+          it { expect(loader.send(:ticket_fields_changed?)).to be_falsey }
         end
       end
 
       describe "#ticket_previously_replicated?" do
         let(:loader) { described_class.send(:new, jira_project, row) }
-        let(:replicated_tickets) { { "123" => "a_ticket" } }
+        let(:replicated_tickets) { { "123" => "a_ticket", "880" => "another_ticket" } }
 
         before { expect(jira_project).to receive(:replicated_tickets).and_return(replicated_tickets) }
 
         context "when previously replicated" do
           let(:row) { { id: "123" } }
 
-          it { expect(loader.ticket_previously_replicated?).to be_truthy }
+          it { expect(loader.send(:ticket_previously_replicated?)).to be_truthy }
         end
 
         context "when previously replicated" do
           let(:row) { { id: "456" } }
 
-          it { expect(loader.ticket_previously_replicated?).to be_falsey }
+          it { expect(loader.send(:ticket_previously_replicated?)).to be_falsey }
         end
       end
 
-      describe "#transition_ticket_to_the_expected_status" do
+      # rubocop:disable Metrics/BlockLength
+      context "when caring for the source ticket link" do
+        def build_link(url, title, application_name = "Ticket Source")
+          RowLoader.build_ticket_link_attributes(url, title, application_name)
+        end
+
         let(:loader) { described_class.send(:new, jira_project, row) }
-        let(:row) { { id: "123", status: "Testing" } }
+        let(:row) { { id: "123", source_ticket_url: "https://url/to/source/ticket/123" } }
+        let(:ticket) { instance_double(Ticket, jira_ticket: jira_ticket) }
+        let(:jira_ticket) { double(JIRA::Resource::Issue, remotelink: double(build: remotelink)) }
+        let(:remotelink) { instance_double(JIRA::Resource::Remotelink) }
 
-        let(:ticket) { double(Ticket) }
+        before { allow(loader).to receive_messages(ticket: ticket) }
 
-        it do
-          expect(loader).to receive(:ticket).at_least(:once).and_return(ticket)
-          expect(ticket).to receive(:transition_to).with("Testing")
+        let(:expected_link) { build_link("https://url/to/source/ticket/123", "Source Ticket 123") }
+
+        describe "#source_ticket_link_title" do
+          it { expect(loader.send(:source_ticket_link_title)).to eq("Source Ticket 123") }
+        end
+
+        describe "#update_source_ticket_remote_link" do
+          before do
+            allow(loader).to receive_messages(source_ticket_link_needs_update?: needs_update)
+          end
+
+          context "when the link does not exist" do
+            let(:needs_update) { true }
+
+            before { allow(ticket).to receive_messages(source_ticket_link: nil) }
+
+            it "setups the link" do
+              expect(remotelink).to receive(:save!).with(expected_link)
+
+              loader.send(:update_source_ticket_remote_link)
+            end
+          end
+
+          context "when the link needs to be updated" do
+            let(:needs_update) { true }
+            let(:source_ticket_link) { instance_double(JIRA::Resource::Remotelink) }
+
+            before { allow(ticket).to receive_messages(source_ticket_link: source_ticket_link) }
+
+            it "deletes the previous link and creates a new one" do
+              expect(source_ticket_link).to receive(:delete)
+              expect(remotelink).to receive(:save!).with(expected_link)
+
+              loader.send(:update_source_ticket_remote_link)
+            end
+          end
+
+          context "when the link does not need to be updated" do
+            let(:needs_update) { false }
+
+            it "no link creation happens" do
+              expect(remotelink).not_to receive(:save!)
 
-          loader.transition_ticket_to_the_expected_status
+              loader.send(:update_source_ticket_remote_link)
+            end
+          end
+        end
+
+        describe "#source_ticket_link_needs_update?" do
+          before do
+            allow(ticket).to receive_messages(source_ticket_link: remote_link)
+          end
+
+          context "when link has yet to be created" do
+            let(:remote_link) { nil }
+
+            it { expect(loader.send(:source_ticket_link_needs_update?)).to be_truthy }
+          end
+
+          context "when link already exists" do
+            let(:remote_link) do
+              instance_double(JIRA::Resource::Remotelink,
+                              attrs: source_ticket_link,
+                              inspect: "<JIRA::Resource::Remotelink attrs: #{source_ticket_link}>")
+            end
+
+            context "when the link is not up to date" do
+              let(:source_ticket_link) { build_link(existing_url, existing_title) }
+
+              context "when url has changed" do
+                let(:existing_url) { "https://__OLD_URL__/to/source/ticket/1234" }
+                let(:existing_title) { "Source Ticket 123" }
+
+                it { expect(loader.send(:source_ticket_link_needs_update?)).to be_truthy }
+              end
+
+              context "when title has changed" do
+                let(:existing_url) { "https://url/to/source/ticket/123" }
+                let(:existing_title) { "__OLD TITLE__Source Ticket 1234" }
+
+                it { expect(loader.send(:source_ticket_link_needs_update?)).to be_truthy }
+              end
+            end
+
+            context "when the link is up to date" do
+              let(:existing_url) { "https://url/to/source/ticket/123" }
+              let(:existing_title) { "Source Ticket 123" }
+              let(:source_ticket_link) do
+                { "object" => {
+                    "url" => "https://url/to/source/ticket/123",
+                    "title" => "Source Ticket 123",
+                    "icon" => { "title" => "link", "url16x16" => "https://url/to/source/ticket/123/icon" }
+                  },
+                  "application" => { "name" => "Ticket Source" },
+                  "extra_attributes" =>
+                    { "id" => 10_443, "self" => "https://url/to/source/ticket/123/remotelink/10443" } }
+              end
+
+              it("only checks the needed attributes") {
+                expect(loader.send(:source_ticket_link_needs_update?)).to be_falsey
+              }
+            end
+          end
+        end
+        # rubocop:enable Metrics/BlockLength
+
+        describe "#transition_ticket_to_the_expected_status" do
+          let(:loader) { described_class.send(:new, jira_project, row) }
+          let(:row) { { id: "123", status: "Testing" } }
+
+          let(:ticket) { double(Ticket) }
+
+          it do
+            expect(loader).to receive(:ticket).at_least(:once).and_return(ticket)
+            expect(ticket).to receive(:transition_to).with("Testing")
+
+            loader.send(:transition_ticket_to_the_expected_status)
+          end
         end
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
-
-  # rubocop:enable Metrics/ClassLength
 end