ticket-replicator 0.1.1

data/spec/ticket/replicator/row_loader_spec.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require "ticket/replicator/row_loader"
+
+module Ticket
+  # rubocop:disable Metrics/ClassLength
+  class Replicator
+    RSpec.describe RowLoader do
+      let(:loader) { described_class.send(:new, jira_project, :a_row) }
+
+      let(:jira_project) { instance_double(JiraProject, project_key: "PROJKEY", ticket_type_name: "Bug") }
+
+      describe ".run_on" do
+        it do
+          expect(described_class).to receive(:new).with(jira_project, :a_row).and_return(loader)
+          expect(loader).to receive(:run)
+
+          described_class.run_on(jira_project, :a_row)
+        end
+      end
+
+      describe ".fields_to_load" do
+        it { expect(described_class.fields_to_load).to eq(%i[id status resolution priority team summary]) }
+      end
+
+      describe "#run" do
+        it do
+          expect(loader).to receive(:save_ticket)
+          expect(loader).to receive(:transition_ticket_to_the_expected_status)
+
+          loader.run
+        end
+      end
+
+      describe "#jira_ticket" do
+        before { expect(loader).to receive(:ticket_previously_replicated?).and_return(previously_replicated?) }
+
+        context "when the ticket has yet to be replicated" do
+          let(:previously_replicated?) { false }
+
+          it do
+            expect(loader).to receive(:create_ticket)
+
+            loader.ticket
+          end
+        end
+
+        context "when the ticket was already replicated" do
+          let(:previously_replicated?) { true }
+
+          it do
+            expect(loader).to receive(:fetch_ticket)
+
+            loader.ticket
+          end
+        end
+      end
+
+      describe "#fetch_ticket" do
+        let(:loader) { described_class.send(:new, jira_project, { id: "123" }) }
+
+        let(:replicated_tickets) { { "123" => :a_ticket, "456" => :another_ticket } }
+
+        it do
+          expect(jira_project).to receive(:replicated_tickets).and_return(replicated_tickets)
+
+          expect(loader.fetch_ticket).to be(:a_ticket)
+        end
+      end
+
+      describe "#create_ticket" do
+        let(:loader) { described_class.send(:new, jira_project, {}) }
+        let(:jira_auto_tool) { instance_double(Jira::Auto::Tool, jira_client: jira_client) }
+        let(:jira_client) { instance_double(JIRA::Client, Issue: issue_accessor) }
+        let(:issue_accessor) { double("jira_client.Issue") }
+
+        let(:jira_ticket) { instance_double(JIRA::Resource::Issue) }
+
+        let(:jira_project) do
+          instance_double(JiraProject, jira_client: jira_client, jira_auto_tool: jira_auto_tool)
+        end
+
+        it do
+          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)
+        end
+      end
+
+      describe "#save_ticket" do
+        let(:loader) { described_class.send(:new, jira_project, row) }
+
+        let(:row) do
+          { id: "123", priority: "Low", resolution: "", status: "Open", summary: "PREFIX | summary", team: "A Team" }
+        end
+
+        let(:ticket) { instance_double(Ticket, jira_ticket: jira_ticket) }
+
+        let(:jira_ticket) { double(JIRA::Resource::Issue) }
+
+        before do
+          allow(loader).to receive_messages(ticket: ticket,
+                                            :ticket_fields_need_to_be_updated? => ticket_fields_need_to_be_updated?)
+        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: "" },
+                                                            priority: { name: "Low" },
+                                                            #         team: { name: "A Team" },
+                                                            summary: "PREFIX | summary"
+                                                          }
+                                                        })
+
+            expect(jira_ticket).to receive(:fetch)
+
+            loader.save_ticket
+          end
+        end
+
+        context "when the previously replicated ticket is already up to date" do
+          let(:ticket_fields_need_to_be_updated?) { false }
+
+          it do
+            expect(jira_ticket).not_to receive(:save!)
+            expect(jira_ticket).not_to receive(:fetch)
+
+            loader.save_ticket
+          end
+        end
+      end
+
+      describe "#ticket_fields_need_to_be_updated?" do
+        before do
+          allow(loader).to receive_messages(ticket_previously_replicated?: ticket_previously_replicated?,
+                                            ticket_fields_changed?: ticket_fields_changed?)
+        end
+
+        context "when has yet to be replicated" do
+          let(:ticket_previously_replicated?) { false }
+          let(:ticket_fields_changed?) { false }
+
+          it { expect(loader.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 }
+        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 }
+        end
+      end
+
+      describe "#ticket_fields_changed?" do
+        let(:row) do
+          { id: "123", priority: "Low", resolution: "", status: "Open", summary: "PREFIX | summary", team: "A Team" }
+        end
+
+        let(:loader) { described_class.send(:new, jira_project, row) }
+        let(:jira_ticket) { double(JIRA::Resource::Issue, summary: current_summary, priority: current_priority) }
+
+        before do
+          expect(loader).to receive(:ticket).at_least(:once).and_return(jira_ticket)
+        end
+
+        context "when both summary and priority changed" do
+          let(:current_summary) { "PREFIX | different summary" }
+          let(:current_priority) { "High" }
+
+          it { expect(loader.ticket_fields_changed?).to be_truthy }
+        end
+
+        context "when only summary changed" do
+          let(:current_summary) { "PREFIX | different summary" }
+          let(:current_priority) { "Low" }
+
+          it { expect(loader.ticket_fields_changed?).to be_truthy }
+        end
+
+        context "when only priority changed" do
+          let(:current_summary) { "PREFIX | summary" }
+          let(:current_priority) { "High" }
+
+          it { expect(loader.ticket_fields_changed?).to be_truthy }
+        end
+
+        context "when neither summary nor priority changed" do
+          let(:current_summary) { "PREFIX | summary" }
+          let(:current_priority) { "Low" }
+
+          it { expect(loader.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" } }
+
+        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 }
+        end
+
+        context "when previously replicated" do
+          let(:row) { { id: "456" } }
+
+          it { expect(loader.ticket_previously_replicated?).to be_falsey }
+        end
+      end
+
+      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.transition_ticket_to_the_expected_status
+        end
+      end
+    end
+  end
+
+  # rubocop:enable Metrics/ClassLength
+end

data/spec/ticket/replicator/row_transformer_spec.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "ticket/replicator/row_transformer"
+
+RSpec.describe Ticket::Replicator::RowTransformer do
+  let(:transformer) { described_class.send(:new, extracted_row) }
+
+  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)
+
+      expect(transformer).to receive(:run)
+
+      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
+
+    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)")
+
+      expect(transformer.run)
+        .to eq(["123", "Open", "", "Low", "Transformed Team", "transformed summary (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
+
+    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)" },
+          "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
+
+  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)", "team" => "Defect Team (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", "team" => "system team" })
+      end
+    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" } }
+
+      before { allow(transformer).to receive_messages(remapped_field_extracted_row: remapped_field_extracted_row) }
+
+      describe "#transformed_id" do
+        let(:remapped_field_extracted_row) { { "id" => "123" } }
+        let(:mappings) { {} }
+
+        it "returns the ID" do
+          expect(transformer.transformed_id).to eq("123")
+        end
+      end
+
+      describe "#transformed_summary" do
+        let(:remapped_field_extracted_row) { { "id" => "426", "summary" => "a summary" } }
+        let(:mappings) { {} }
+
+        before do
+          allow(Ticket::Replicator::ReplicatedSummary)
+            .to receive(:build).with("426", "a summary").and_return("replicated_summary")
+        end
+
+        it "returns the summary" do
+          expect(transformer.transformed_summary).to eq("replicated_summary")
+        end
+      end
+
+      shared_examples "an unmapped value handler" do |field_name, source_field|
+        source_field ||= field_name
+
+        let(:remapped_field_extracted_row) { { source_field.to_s => an_original_value } }
+
+        let(:an_original_value) { "any #{field_name} #{rand}" }
+
+        let(:transformed_value) { transformer.send("transformed_#{field_name}") }
+
+        context "when defaulting to original value" do
+          let(:mappings) { { "#{field_name}_mapping" => { "defaults_to" => "keep_original_value" } } }
+
+          it { expect(transformed_value).to eq(an_original_value) }
+        end
+
+        context "when the status is unexpected" do
+          let(:mappings) do
+            { "#{field_name}_mapping" => { "extracted value" => "transformed value" } }
+          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
+
+      describe "#transformed_status" do
+        let(:mappings) do
+          { "status_mapping" => { "Open" => "Open", "Closed" => "Closed" } }
+        end
+
+        let(:remapped_field_extracted_row) { { "status" => "Open" } }
+
+        it "returns the status" do
+          expect(transformer.transformed_status).to eq("Open")
+        end
+
+        it_behaves_like "an unmapped value handler", :status
+      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) { { "team_mapping" => { "Source Team" => "Transformed Team", "Front End" => "Web Team" } } }
+
+        let(:remapped_field_extracted_row) { { "team" => "Source Team" } }
+
+        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

data/spec/ticket/replicator/setup_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "ticket/replicator/setup"
+
+module Ticket
+  class Replicator
+    class Setup
+      RSpec.describe Setup do
+        let(:setup) { described_class.new(replicator) }
+        let(:replicator) { instance_double(Replicator) }
+        let(:logger) { instance_double(Logger, info: nil, error: nil) }
+
+        before { allow(setup).to receive_messages(log: logger) }
+
+        describe "#run" do
+          it do
+            expect(setup).to receive(:create_queue)
+            expect(setup).to receive(:create_initial_configuration)
+
+            setup.run
+          end
+        end
+
+        describe "#create_queue" do
+          it do
+            expect(replicator).to receive(:extracted_folder).and_return("queue/10.extracted")
+
+            expect(logger).to receive(:info).with(%(Created folder "queue/10.extracted"))
+
+            setup.send(:create_queue)
+          end
+        end
+
+        describe "#create_initial_configuration" do
+          let(:expected_config_path) { "config/ticket-replicator.mappings.yml" }
+
+          before { allow(File).to receive(:exist?).with(expected_config_path).and_return(config_exists) }
+
+          context "when the config file does not exist" do
+            let(:config_exists) { false }
+
+            it do
+              allow(setup).to receive_messages(example_config_file_path: "path/to/example_config.yml")
+
+              expect(FileUtils).to receive(:mkdir_p).with("config")
+
+              expect(FileUtils).to receive(:cp).with("path/to/example_config.yml", expected_config_path)
+
+              expect(logger).to receive(:info) do |&block|
+                expect(block.call).to eq("Created file #{expected_config_path.inspect}")
+              end
+
+              setup.send(:create_initial_configuration)
+            end
+          end
+
+          context "when the config file already exists" do
+            let(:config_exists) { true }
+
+            it "does not overwrite it" do
+              expect(FileUtils).not_to receive(:cp)
+
+              expect { setup.send(:create_initial_configuration) }
+                .to raise_error(SetupError, "Not overwriting existing config file #{expected_config_path.inspect}")
+            end
+          end
+        end
+
+        describe "#example_config_file_path" do
+          it do
+            allow(replicator).to receive_messages(home_dir: "REPLICATOR_HOME")
+
+            expect(setup.send(:example_config_file_path))
+              .to eq("REPLICATOR_HOME/config/examples/ticket-replicator.mappings.yml")
+          end
+        end
+      end
+    end
+  end
+end