ticket-replicator 1.0.0 → 1.2.0

data/spec/ticket/replicator/row_transformer_spec.rb

@@ -2,245 +2,340 @@
 
 require "ticket/replicator/row_transformer"
 
-RSpec.describe Ticket::Replicator::RowTransformer do
-  let(:transformer) { described_class.send(:new, extracted_row) }
+module Ticket
+  class Replicator
+    # rubocop:disable Metrics/ClassLength
+    class RowTransformer
+      RSpec.describe RowTransformer do
+        let(:transformer) { described_class.send(:new, extracted_row) }
 
-  describe ".run_on" do
-    let(:extracted_row) { :a_row_to_transform }
+        describe ".run_on" do
+          let(:extracted_row) { :a_row_to_transform }
 
-    it "transforms the given file" do
-      expect(described_class).to receive(:new).with(:a_row_to_transform).and_return(transformer)
+          it "transforms the given file" do
+            expect(described_class).to receive(:new).with(:a_row_to_transform).and_return(transformer)
 
-      expect(transformer).to receive(:run)
+            expect(transformer).to receive(:run)
 
-      described_class.run_on(:a_row_to_transform)
-    end
-  end
+            described_class.run_on(:a_row_to_transform)
+          end
+        end
 
-  describe "#run" do
-    let(:extracted_row) do
-      {
-        id: "123",
-        status: "Open",
-        priority: "4 - Low",
-        team: "Source Team",
-        summary: "summary"
-      }
-    end
+        describe "#run" do
+          let(:extracted_row) do
+            {
+              id: "123",
+              status: "Open",
+              priority: "4 - Low",
+              team: "Source Team",
+              summary: "summary"
+            }
+          end
 
-    it "transforms a row" do
-      allow(transformer).to receive(:transformed_id).and_return("123")
-      allow(transformer).to receive(:transformed_status).and_return("Open")
-      allow(transformer).to receive(:transformed_resolution).and_return("")
-      allow(transformer).to receive(:transformed_priority).and_return("Low")
-      allow(transformer).to receive(:transformed_team).and_return("Transformed Team")
-      allow(transformer).to receive(:transformed_summary).and_return("transformed summary (123)")
+          it "transforms a row" do
+            allow(transformer).to receive(:transformed_id).and_return("123")
+            allow(transformer).to receive(:transformed_status).and_return("Open")
+            allow(transformer).to receive(:transformed_resolution).and_return("")
+            allow(transformer).to receive(:transformed_priority).and_return("Low")
+            allow(transformer).to receive(:transformed_summary).and_return("transformed summary (123)")
+            allow(transformer).to receive(:transformed_source_ticket_url).and_return("url/to/source/ticket/123")
 
-      expect(transformer.run)
-        .to eq(["123", "Open", "", "Low", "transformed summary (123)"])
-    end
-  end
+            expect(transformer.run)
+              .to eq(["123", "Open", "", "Low", "transformed summary (123)", "url/to/source/ticket/123"])
+          end
+        end
 
-  describe "#mappings" do
-    let(:mappings_yaml) do
-      <<~YAML
-        field_mapping:
-          id: Defect
-          summary: Defect (2)
-        status_mapping:
-          defaults_to: keep_original_value
-          Open: Open
-          Closed: Closed
-        resolution_mapping:
-          Closed: Done
-          Rejected: Won't Fix
-        team_mapping:
-          Source Team: Transformed Team
-          Front End: Web Team
-        priority_mapping:
-          1 - Critical: Critical
-          2 - High: High
-          3 - Medium: Medium
-          4 - Low: Low
-      YAML
-    end
+        describe "#mappings" do
+          let(:mappings_yaml) do
+            <<~'YAML'
+              field_mapping:
+                id: Defect
+                summary: Defect (2)
+              id_extraction_regex: "\\((?<id>\\d+)\\)$"
+              status_mapping:
+                defaults_to: keep_original_value
+                Open: Open
+                Closed: Closed
+              resolution_mapping:
+                Closed: Done
+                Rejected: Won't Fix
+              team_mapping:
+                Source Team: Transformed Team
+                Front End: Web Team
+              priority_mapping:
+                1 - Critical: Critical
+                2 - High: High
+                3 - Medium: Medium
+                4 - Low: Low
+            YAML
+          end
 
-    let(:extracted_row) { {} }
+          let(:extracted_row) { {} }
+
+          let(:file_io) { instance_double(IO) }
+
+          it "loads the mappings from the mappings.yml file" do
+            expect(IO).to receive(:open).with("config/ticket-replicator.mappings.yml",
+                                              "r:bom|utf-8").and_yield(mappings_yaml)
+
+            expect(transformer.mappings)
+              .to eq(
+                "field_mapping" => { "id" => "Defect", "summary" => "Defect (2)" },
+                "id_extraction_regex" => "\\((?<id>\\d+)\\)$",
+                "status_mapping" => { "defaults_to" => "keep_original_value", "Open" => "Open",
+                                      "Closed" => "Closed" },
+                "resolution_mapping" => { "Closed" => "Done", "Rejected" => "Won't Fix" },
+                "team_mapping" => { "Source Team" => "Transformed Team", "Front End" => "Web Team" },
+                "priority_mapping" =>
+                  { "1 - Critical" => "Critical", "2 - High" => "High", "3 - Medium" => "Medium",
+                    "4 - Low" => "Low" }
+              )
+          end
+        end
 
-    let(:file_io) { instance_double(IO) }
+        describe "#ticket_replicator_source_ticket_url" do
+          let(:extracted_row) { {} }
 
-    it "loads the mappings from the mappings.yml file" do
-      expect(IO).to receive(:open).with("config/ticket-replicator.mappings.yml", "r:bom|utf-8").and_yield(mappings_yaml)
+          context "when the source ticket url is set in the environment" do
+            before do
+              allow(ENV)
+                .to receive(:fetch).with("TICKET_REPLICATOR_SOURCE_TICKET_URL").and_return("url/to/source/ticket")
+            end
 
-      expect(transformer.mappings)
-        .to eq(
-          "field_mapping" => { "id" => "Defect", "summary" => "Defect (2)" },
-          "status_mapping" => { "defaults_to" => "keep_original_value", "Open" => "Open", "Closed" => "Closed" },
-          "resolution_mapping" => { "Closed" => "Done", "Rejected" => "Won't Fix" },
-          "team_mapping" => { "Source Team" => "Transformed Team", "Front End" => "Web Team" },
-          "priority_mapping" =>
-            { "1 - Critical" => "Critical", "2 - High" => "High", "3 - Medium" => "Medium", "4 - Low" => "Low" }
-        )
-    end
-  end
+            it { expect(transformer.ticket_replicator_source_ticket_url).to eq("url/to/source/ticket") }
+          end
 
-  describe "using mappings" do
-    before { allow(transformer).to receive_messages(mappings: mappings) }
-
-    describe "#remapped_field_extracted_row" do
-      let(:mappings) do
-        {
-          "field_mapping" => {
-            "id" => "Defect", "priority" => "Defect Priority", "resolution" => "Defect (2)",
-            "status" => "Defect status", "summary" => "Defect (2)"
-          }
-        }
-      end
+          context "when the source ticket url is not set in the environment" do
+            it do
+              expect { transformer.ticket_replicator_source_ticket_url }
+                .to raise_error("TICKET_REPLICATOR_SOURCE_TICKET_URL: not set in environment!")
+            end
+          end
+        end
 
-      let(:extracted_row) do
-        {
-          "defect (2)" => "a summary", "defect priority" => "High", "defect status" => "Open",
-          "defect team (2)" => "system team", "defect" => "123"
-        }
-      end
+        describe "#source_ticket_url_builder" do
+          let(:extracted_row) { {} }
 
-      it do
-        expect(transformer.remapped_field_extracted_row)
-          .to eq({ "id" => "123", "priority" => "High", "resolution" => "a summary",
-                   "status" => "Open", "summary" => "a summary" })
-      end
-    end
+          before do
+            allow(transformer)
+              .to receive_messages(ticket_replicator_source_ticket_url: ticket_replicator_source_ticket_url)
+          end
 
-    # rubocop:disable Metrics/BlockLength
-    context "when remapped field extracted row used" do
-      let(:extracted_row) { { :extracted_row => "should not be used in this context but the remapped version" } }
+          context "when the URL has no syntax error" do
+            let(:ticket_replicator_source_ticket_url) { "http://url/to/source/ticket/<%= source_ticket_id %>" }
 
-      before { allow(transformer).to receive_messages(remapped_field_extracted_row: remapped_field_extracted_row) }
+            it { expect(transformer.source_ticket_url_builder("123")).to eq("http://url/to/source/ticket/123") }
+          end
 
-      describe "#transformed_id" do
-        let(:remapped_field_extracted_row) { { "id" => "123" } }
-        let(:mappings) { {} }
+          context "when the URL has a syntax error" do
+            let(:ticket_replicator_source_ticket_url) { "http://url/to/source/ticket/<%= missing_variable %>" }
 
-        it "returns the ID" do
-          expect(transformer.transformed_id).to eq("123")
+            it { expect { transformer.source_ticket_url_builder("123") }.to raise_error(StandardError) }
+          end
         end
-      end
 
-      describe "#transformed_summary" do
-        let(:remapped_field_extracted_row) { { "id" => "426", "summary" => "a summary" } }
-        let(:mappings) { {} }
+        describe "using mappings" do
+          before { allow(transformer).to receive_messages(mappings: mappings) }
+
+          describe "#remapped_field_extracted_row" do
+            let(:mappings) do
+              {
+                "field_mapping" => {
+                  "id" => "Defect", "priority" => "Defect Priority", "resolution" => "Defect (2)",
+                  "status" => "Defect status", "summary" => "Defect (2)"
+                }
+              }
+            end
+
+            let(:extracted_row) do
+              {
+                "defect (2)" => "a summary", "defect priority" => "High", "defect status" => "Open",
+                "defect team (2)" => "system team", "defect" => "123"
+              }
+            end
+
+            it do
+              expect(transformer.remapped_field_extracted_row)
+                .to eq({ "id" => "123", "priority" => "High", "resolution" => "a summary",
+                         "status" => "Open", "summary" => "a summary" })
+            end
+          end
 
-        before do
-          allow(Ticket::Replicator::ReplicatedSummary)
-            .to receive(:build).with("426", "a summary").and_return("replicated_summary")
-        end
+          # rubocop:disable Metrics/BlockLength
+          context "when remapped field extracted row used" do
+            let(:extracted_row) { { :extracted_row => "should not be used in this context but the remapped version" } }
 
-        it "returns the summary" do
-          expect(transformer.transformed_summary).to eq("replicated_summary")
-        end
-      end
+            before do
+              allow(transformer).to receive_messages(remapped_field_extracted_row: remapped_field_extracted_row)
+            end
 
-      shared_examples "an unmapped value handler" do |field_name, source_field|
-        source_field ||= field_name
+            describe "#transformed_id" do
+              context "when using the ID value as is" do
+                let(:mappings) { {} }
+                let(:remapped_field_extracted_row) { { "id" => "123" } }
 
-        let(:remapped_field_extracted_row) { { source_field.to_s => an_original_value } }
+                it "returns the ID" do
+                  expect(transformer.transformed_id).to eq("123")
+                end
+              end
 
-        let(:an_original_value) { "any #{field_name} #{rand}" }
+              context "when extracting the ID from the string" do
+                let(:remapped_field_extracted_row) { { "id" => "also (85)73 in summary (123456)" } }
+                let(:mappings) { { "id_extraction_regex" => "\\((?<id>\\d+)\\)$" } }
 
-        let(:transformed_value) { transformer.send("transformed_#{field_name}") }
+                it { expect(transformer.transformed_id).to eq("123456") }
 
-        context "when defaulting to original value" do
-          let(:mappings) { { "#{field_name}_mapping" => { "defaults_to" => "keep_original_value" } } }
+                context "when the regex does not match" do
+                  let(:remapped_field_extracted_row) { { "id" => "summary (non numeric)" } }
 
-          it { expect(transformed_value).to eq(an_original_value) }
-        end
+                  it "raises an error" do
+                    expect { transformer.transformed_id }
+                      .to raise_error(FileTransformer::TransformError,
+                                      %(No match found for :id in "summary (non numeric)") +
+                                      " using /\\((?<id>\\d+)\\)$/")
+                  end
+                end
+              end
+            end
 
-        context "when defaulting to unset value" do
-          let(:mappings) { { "#{field_name}_mapping" => { "defaults_to" => "unset_value" } } }
+            describe "#transformed_source_ticket_url" do
+              let(:remapped_field_extracted_row) { { "id" => "123" } }
+              let(:mappings) { {} }
 
-          it { expect(transformed_value).to eq(nil) }
-        end
+              before do
+                allow(transformer)
+                  .to receive_messages(
+                    transformed_id: "123",
+                    ticket_replicator_source_ticket_url: "url/to/source/ticket/<%= source_ticket_id %>"
+                  )
+              end
 
-        context "when defaulting to blank value" do
-          let(:mappings) { { "#{field_name}_mapping" => { "defaults_to" => "blank_value" } } }
+              it "returns the source ticket url" do
+                expect(transformer.transformed_source_ticket_url).to eq("url/to/source/ticket/123")
+              end
+            end
 
-          it { expect(transformed_value).to eq("") }
-        end
+            describe "#transformed_summary" do
+              let(:remapped_field_extracted_row) { { "id" => "426", "summary" => "a summary" } }
+              let(:mappings) { {} }
 
-        context "when the value is unexpected" do
-          let(:mappings) do
-            { "#{field_name}_mapping" => { "extracted value" => "transformed value" } }
-          end
+              before do
+                allow(ReplicatedSummary).to receive(:build).with("426", "a summary").and_return("replicated_summary")
+              end
 
-          it do
-            expect { transformed_value }
-              .to raise_error(RuntimeError,
-                              "No mapping found for #{field_name.inspect} = #{an_original_value.inspect} " \
-                              "in #{mappings["#{field_name}_mapping"].inspect}")
-          end
-        end
-      end
+              it "returns the summary" do
+                expect(transformer.transformed_summary).to eq("replicated_summary")
+              end
+            end
 
-      describe "#transformed_status" do
-        let(:mappings) do
-          { "status_mapping" => { "Open" => "Open", "Closed" => "Closed" } }
-        end
+            shared_examples "an unmapped value handler" do |field_name, source_field|
+              source_field ||= field_name
 
-        let(:remapped_field_extracted_row) { { "status" => "Open" } }
+              let(:remapped_field_extracted_row) { { source_field.to_s => an_original_value } }
 
-        it "returns the status" do
-          expect(transformer.transformed_status).to eq("Open")
-        end
+              let(:an_original_value) { "any #{field_name} #{rand}" }
 
-        it_behaves_like "an unmapped value handler", :status
-      end
+              let(:transformed_value) { transformer.send("transformed_#{field_name}") }
 
-      describe "#transformed_resolution" do
-        let(:mappings) { { "resolution_mapping" => { "Closed" => "Done", "Rejected" => "Won't Fix" } } }
+              context "when defaulting to original value" do
+                let(:mappings) { { "#{field_name}_mapping" => { "defaults_to" => "keep_original_value" } } }
 
-        context "when the status is Closed" do
-          let(:remapped_field_extracted_row) { { "status" => "Closed" } }
+                it { expect(transformed_value).to eq(an_original_value) }
+              end
 
-          it "returns the resolution" do
-            expect(transformer.transformed_resolution).to eq("Done")
-          end
-        end
+              context "when defaulting to unset value" do
+                let(:mappings) { { "#{field_name}_mapping" => { "defaults_to" => "unset_value" } } }
 
-        context "when the status is Rejected" do
-          let(:remapped_field_extracted_row) { { "status" => "Rejected" } }
+                it { expect(transformed_value).to eq(nil) }
+              end
 
-          it "returns the resolution" do
-            expect(transformer.transformed_resolution).to eq("Won't Fix")
-          end
-        end
+              context "when defaulting to blank value" do
+                let(:mappings) { { "#{field_name}_mapping" => { "defaults_to" => "blank_value" } } }
 
-        it_behaves_like "an unmapped value handler", :resolution, :status
-      end
+                it { expect(transformed_value).to eq("") }
+              end
 
-      describe "#transformed_team" do
-        let(:mappings) { { "team_mapping" => { "Source Team" => "Transformed Team", "Front End" => "Web Team" } } }
+              context "when the value is unexpected" do
+                let(:mappings) do
+                  { "#{field_name}_mapping" => { "extracted value" => "transformed value" } }
+                end
 
-        let(:remapped_field_extracted_row) { { "team" => "Source Team" } }
+                it do
+                  expect { transformed_value }
+                    .to raise_error(RuntimeError,
+                                    "No mapping found for #{field_name.inspect} = #{an_original_value.inspect} " \
+                                    "in #{mappings["#{field_name}_mapping"].inspect}")
+                end
+              end
+            end
 
-        it "returns the team" do
-          expect(transformer.transformed_team).to eq("Transformed Team")
-        end
+            describe "#transformed_status" do
+              let(:mappings) do
+                { "status_mapping" => { "Open" => "Open", "Closed" => "Closed" } }
+              end
 
-        it_behaves_like "an unmapped value handler", :team
-      end
+              let(:remapped_field_extracted_row) { { "status" => "Open" } }
 
-      describe "#transformed_priority" do
-        let(:mappings) { { "priority_mapping" => { "1 - Critical" => "Critical", "2 - High" => "High" } } }
+              it "returns the status" do
+                expect(transformer.transformed_status).to eq("Open")
+              end
 
-        let(:remapped_field_extracted_row) { { "priority" => "1 - Critical" } }
+              it_behaves_like "an unmapped value handler", :status
+            end
 
-        it "returns the priority" do
-          expect(transformer.transformed_priority).to eq("Critical")
-        end
+            describe "#transformed_resolution" do
+              let(:mappings) { { "resolution_mapping" => { "Closed" => "Done", "Rejected" => "Won't Fix" } } }
+
+              context "when the status is Closed" do
+                let(:remapped_field_extracted_row) { { "status" => "Closed" } }
+
+                it "returns the resolution" do
+                  expect(transformer.transformed_resolution).to eq("Done")
+                end
+              end
+
+              context "when the status is Rejected" do
+                let(:remapped_field_extracted_row) { { "status" => "Rejected" } }
+
+                it "returns the resolution" do
+                  expect(transformer.transformed_resolution).to eq("Won't Fix")
+                end
+              end
+
+              it_behaves_like "an unmapped value handler", :resolution, :status
+            end
+
+            describe "#transformed_team" do
+              let(:mappings) do
+                { "team_mapping" => { "Source Team" => "Transformed Team", "Front End" => "Web Team" } }
+              end
+
+              let(:remapped_field_extracted_row) { { "team" => "Source Team" } }
 
-        it_behaves_like "an unmapped value handler", :priority
+              it "returns the team" do
+                expect(transformer.transformed_team).to eq("Transformed Team")
+              end
+
+              it_behaves_like "an unmapped value handler", :team
+            end
+
+            describe "#transformed_priority" do
+              let(:mappings) { { "priority_mapping" => { "1 - Critical" => "Critical", "2 - High" => "High" } } }
+
+              let(:remapped_field_extracted_row) { { "priority" => "1 - Critical" } }
+
+              it "returns the priority" do
+                expect(transformer.transformed_priority).to eq("Critical")
+              end
+
+              it_behaves_like "an unmapped value handler", :priority
+            end
+          end
+          # rubocop:enable Metrics/BlockLength
+        end
       end
     end
-    # rubocop:enable Metrics/BlockLength
+
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/spec/ticket/replicator/ticket_spec.rb

@@ -136,7 +136,6 @@ module Ticket
       let(:jira_auto_tool) { instance_double(Jira::Auto::Tool) }
       let(:jira_client) { instance_double(JIRA::Client, Field: field_navigator) }
 
-      #  let(:jira_ticket) { OpenStruct.new(jira_ticket_properties_hash["fields"]) }
       let(:jira_ticket) { JIRA::Resource::Issue.build(jira_client, jira_ticket_properties_hash) }
 
       let(:ticket) { described_class.new(jira_auto_tool, jira_ticket) }
@@ -149,6 +148,56 @@ module Ticket
         it { expect(ticket.summary).to eq("SMAN-16384 | Login page randomly fails to load CSS assets (10001)") }
       end
 
+      def build_ticket_link(url, title, application = Ticket::SOURCE_TICKET_REMOTE_LINK_APPLICATION)
+        double(JIRA::Resource::Remotelink, attrs: RowLoader.build_ticket_link_attributes(url, title, application))
+      end
+
+      describe "#source_ticket_link" do
+        let(:ticket_links) { [double(JIRA::Resource::Remotelink, attrs: {}), source_ticket_jira_link].compact }
+
+        before { allow(jira_ticket).to receive_messages(remotelink: double(all: ticket_links)) }
+
+        let(:source_ticket_jira_link) { build_ticket_link("https://ur/to/source/ticket/16384", "Source Ticket 16384") }
+
+        it { expect(ticket.source_ticket_link).to eq(source_ticket_jira_link) }
+
+        context "when no source ticket is linked" do
+          let(:source_ticket_jira_link) { nil }
+          it { expect(ticket.source_ticket_link).to be_nil }
+        end
+
+        context "when the existing remote link is not a ticket source link (no application specified)" do
+          let(:source_ticket_jira_link) do
+            build_ticket_link("https://ur/to/source/ticket/16384", "Source Ticket 16384", nil)
+          end
+
+          it { expect(ticket.source_ticket_link).to be_nil }
+        end
+
+        context "when the existing remote link is not a ticket source link (another application specified)" do
+          let(:source_ticket_jira_link) do
+            build_ticket_link("https://ur/to/source/ticket/16384", "Source Ticket 16384", "Another application")
+          end
+
+          it { expect(ticket.source_ticket_link).to be_nil }
+        end
+      end
+
+      describe "#source_ticket_url" do
+        before do
+          allow(ticket).to receive_messages(source_ticket_link: source_ticket_jira_link)
+        end
+
+        let(:source_ticket_jira_link) { build_ticket_link("https://ur/to/source/ticket/16384", "Source Ticket 16384") }
+
+        it { expect(ticket.source_ticket_url).to eq("https://ur/to/source/ticket/16384") }
+
+        context "when no source ticket is linked" do
+          let(:source_ticket_jira_link) { nil }
+          it { expect(ticket.source_ticket_url).to be_nil }
+        end
+      end
+
       describe "replicated?" do
         let(:ticket) { described_class.new(jira_auto_tool, jira_ticket) }
         let(:jira_ticket) { double(JIRA::Resource::Issue, summary: actual_summary) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ticket-replicator
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Christophe Broult
@@ -146,6 +146,7 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Guardfile