ticket-replicator 0.1.1

data/spec/ticket/replicator/file_loader_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "ticket/replicator/file_loader"
+
+module Ticket
+  class Replicator
+    class FileLoader
+      RSpec.describe FileLoader do
+        let(:loader) { described_class.send(:new, jira_project, "file.csv") }
+        let(:jira_project) { instance_double(JiraProject) }
+        let(:logger) { instance_double(Logger, info: nil) }
+
+        describe ".run_on" do
+          it "loads the given file" do
+            expect(described_class).to receive(:new).with(jira_project, "file.csv").and_return(loader)
+            expect(described_class).to receive(:log).and_return(logger)
+            expect(loader).to receive(:run)
+
+            described_class.run_on(jira_project, "file.csv")
+          end
+        end
+
+        describe "#run" do
+          let(:rows) { %i[a_row another_row] }
+          before do
+            expect(loader).to receive(:rows).and_return(rows)
+          end
+
+          it "loads each rows" do
+            rows.each { |row| expect(RowLoader).to receive(:run_on).with(jira_project, row) }
+
+            loader.run
+          end
+
+          context "when a row loading error occurs" do
+            before do
+              allow(RowLoader).to receive(:run_on).with(jira_project, :a_row)
+              allow(RowLoader).to receive(:run_on).with(jira_project, :another_row)
+                                                  .and_raise(LoadError, "error")
+            end
+
+            it "raises an error message including the file name and line number of the row that was processed" do
+              expect { loader.run }.to raise_error(LoadError, <<~EOEXPECTEDERRORMSG)
+                file.csv:3: error while loading row:
+                error:
+                :another_row
+              EOEXPECTEDERRORMSG
+            end
+          end
+        end
+
+        describe "#rows" do
+          let(:csv) do
+            <<~EOCSV
+              ID,Status,Priority,Team,Summary
+              123,Open,Low,A Team,summary
+              456,Open,Low,Another Team,summary
+            EOCSV
+          end
+
+          it "reads rows from the CSV" do
+            expect(CSV).to receive(:read).with("file.csv", headers: true, header_converters: :symbol)
+                                         .and_call_original
+
+            expect(IO).to receive(:open).and_return(csv)
+
+            expect(loader.rows.each.to_a.collect(&:to_h))
+              .to eq([
+                       { id: "123", status: "Open", priority: "Low", team: "A Team", summary: "summary" },
+                       { id: "456", status: "Open", priority: "Low", team: "Another Team", summary: "summary" }
+                     ])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ticket/replicator/file_replicator_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Ticket
+  class Replicator
+    # rubocop:disable Metrics/ClassLength
+    class FileReplicator
+      RSpec.describe FileReplicator do
+        let(:file_replicator) { described_class.send(:new, replicator, "extracted.csv") }
+        let(:replicator) { instance_double(Replicator) }
+
+        describe ".run_on" do
+          it "replicates the given file" do
+            expect(described_class).to receive(:new).with(replicator, "file.csv").and_return(file_replicator)
+            expect(file_replicator).to receive(:run)
+
+            described_class.run_on(replicator, "file.csv")
+          end
+        end
+
+        describe ".transform" do
+          it "transforms the given file" do
+            expect(described_class).to receive(:new).with(replicator, "extracted.csv").and_return(file_replicator)
+            expect(file_replicator).to receive(:transform)
+
+            described_class.transform(replicator, "extracted.csv")
+          end
+        end
+        describe ".load" do
+          it "loads the given file" do
+            expect(described_class).to receive(:load).with(replicator, "transformed.csv")
+
+            described_class.load(replicator, "transformed.csv")
+          end
+        end
+
+        describe "#run" do
+          it "replicates the given file content" do
+            expect(file_replicator).to receive(:transform).ordered
+            expect(file_replicator).to receive(:load).ordered
+            expect(file_replicator).to receive(:delete_transformed_file).ordered
+            expect(file_replicator).to receive(:archive_extracted_file).ordered
+
+            file_replicator.run
+          end
+
+          context "when the transform fails" do
+            it "does not archive the extracted file" do
+              expect(file_replicator)
+                .to receive(:transform).and_raise(FileTransformer::TransformError, "error while transforming:")
+
+              expect(file_replicator).not_to receive(:load)
+              expect(file_replicator).not_to receive(:archive_extracted_file)
+
+              expect { file_replicator.run }
+                .to raise_error(FileTransformer::TransformError, "error while transforming:")
+            end
+          end
+
+          context "when the load fails" do
+            it "does not archive the extracted file" do
+              expect(file_replicator).to receive(:transform)
+              expect(file_replicator).to receive(:load).and_raise(FileLoader::LoadError, "error while loading:")
+              expect(file_replicator).not_to receive(:archive_extracted_file)
+
+              expect { file_replicator.run }.to raise_error(FileLoader::LoadError, "error while loading:")
+            end
+          end
+        end
+
+        describe "#transform" do
+          it "transforms the given file" do
+            expect(file_replicator).to receive(:transformed_path).and_return("transformed.csv")
+            expect(FileTransformer).to receive(:run_on).with("extracted.csv", "transformed.csv")
+
+            file_replicator.transform
+          end
+        end
+
+        describe "#load" do
+          it "loads the transformed file" do
+            expect(file_replicator).to receive(:transformed_path).and_return("transformed.csv")
+            expect(replicator).to receive(:jira_project).and_return(:jira_project)
+            expect(FileLoader).to receive(:run_on).with(:jira_project, "transformed.csv")
+
+            file_replicator.load
+          end
+        end
+
+        describe "#delete_transformed_file" do
+          it "deletes the transformed file" do
+            expect(file_replicator).to receive(:transformed_path).and_return("transformed.csv")
+            expect(FileUtils).to receive(:rm).with("transformed.csv")
+
+            file_replicator.delete_transformed_file
+          end
+        end
+
+        describe "#archive_extracted_file" do
+          it "archives the extracted file" do
+            expect(file_replicator)
+              .to receive(:archived_path).and_return("path/to/queue/archived/file")
+
+            expect(FileUtils).to receive(:mv).with("extracted.csv", "path/to/queue/archived/file")
+
+            file_replicator.archive_extracted_file
+          end
+        end
+
+        describe "#transformed_pathr" do
+          before do
+            allow(replicator).to receive_messages(extracted_folder: "queue/extracted")
+            allow(replicator).to receive_messages(transformed_folder: "queue/transformed")
+          end
+
+          context "when the extracted file was a CSV" do
+            let(:file_replicator) { described_class.send(:new, replicator, "queue/extracted/file.csv") }
+
+            it "returns the transformed path for the given file" do
+              expect(file_replicator.transformed_path).to eq("queue/transformed/file.csv")
+            end
+          end
+
+          context "when the extracted file was a XLSX" do
+            let(:file_replicator) { described_class.send(:new, replicator, "queue/extracted/file.xlsx") }
+
+            it "returns the transformed path for the given file" do
+              expect(file_replicator.transformed_path).to eq("queue/transformed/file.csv")
+            end
+          end
+        end
+
+        describe "#archived_path" do
+          it "returns the archived path for the given file" do
+            allow(replicator).to receive_messages(archived_folder: "queue/archived")
+            allow(file_replicator).to receive_messages(timestamp: "<timestamp>")
+
+            expect(file_replicator.archived_path).to eq("queue/archived/<timestamp>.extracted.csv")
+          end
+        end
+
+        describe "#timestamp" do
+          it "returns the current timestamp" do
+            expect(Jira::Auto::Tool::Helpers::OverridableTime)
+              .to receive(:now).and_return(Time.new(2025, 5, 9, 21, 8, 0))
+
+            expect(file_replicator.send(:timestamp)).to eq("2025-05-09.21h08m00")
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/spec/ticket/replicator/file_transformer/for_csv_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+module Ticket
+  class Replicator
+    class FileTransformer
+      class ForCSV
+        RSpec.describe ForCSV do
+          let(:transformer) { described_class.send(:new, "source.csv", "transformed.csv") }
+
+          describe "#extracted_rows" do
+            let(:extracted_csv) do
+              <<~EOCSV
+                ID,Status,Priority,Team,Summary
+                123,Open,4 - Low,Source Team,summary
+                456,Open,4 - Low,Source Team,summary
+              EOCSV
+            end
+
+            it "reads rows from the CSV" do
+              expect(CSV).to receive(:read).with("source.csv", headers: true, header_converters: :downcase)
+                                           .and_call_original
+
+              expect(IO).to receive(:open).and_return(extracted_csv)
+
+              expect(transformer.extracted_rows.each.to_a.collect(&:to_h))
+                .to eq([
+                         { "id" => "123", "priority" => "4 - Low", "status" => "Open",
+                           "summary" => "summary", "team" => "Source Team" },
+                         { "id" => "456", "priority" => "4 - Low", "status" => "Open",
+                           "summary" => "summary", "team" => "Source Team" }
+                       ])
+            end
+
+            context "when reading the CSV generates an error" do
+              it "raises an error message including the file name and line number of the row that was processed" do
+                expect(CSV).to receive(:read).with("source.csv", headers: true, header_converters: :downcase)
+                                             .and_raise(RuntimeError, "parser error")
+
+                expect { transformer.extracted_rows }.to raise_error(CSVReaderError, <<~EOEXPECTEDERRORMSG)
+                  source.csv:1: error while reading CSV file:
+                  parser error
+                EOEXPECTEDERRORMSG
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ticket/replicator/file_transformer/for_xlsx_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "ticket/replicator/file_transformer/for_xlsx"
+
+module Ticket
+  class Replicator
+    class FileTransformer
+      class ForXLSX
+        RSpec.describe ForXLSX do
+          let(:transformer) { described_class.send(:new, "extracted.xlsx", "transformed.csv") }
+
+          describe "#extracted_rows" do
+            let(:column_names) { ("A".."E").to_a }
+            let(:actual_parsed_xlsx_data) do
+              [
+                ["Defect", "status", "priority", "team", "Defect (2)"],
+                ["123", "Open", "4 - Low", "Source Team", "summary"],
+                ["456", "Open", "4 - Low", "Source Team", "summary"]
+              ].collect { |values| column_names.zip(values).to_h }
+            end
+
+            let(:xlsx_content) { "xlsx content" }
+
+            let(:workbook) { instance_double(Creek::Book, sheets: [extracted_data_sheet]) }
+            let(:extracted_data_sheet) { instance_double(Creek::Sheet, simple_rows: actual_parsed_xlsx_data) }
+
+            it "reads rows from the XLSX" do
+              expect(Creek::Book).to receive(:new).with("extracted.xlsx", { :convert_numerics => false })
+                                                  .and_return(workbook)
+
+              expect(transformer.extracted_rows)
+            end
+
+            context "when reading the XLSX generates an error" do
+              it "raises an error message including the file name" do
+                expect(Creek::Book).to receive(:new).with("extracted.xlsx", { :convert_numerics => false })
+                                                    .and_raise(RuntimeError, "parser error")
+
+                expect { transformer.extracted_rows }.to raise_error(XLSXReaderError, <<~EOEXPECTEDERRORMSG)
+                  extracted.xlsx:1: error while reading XLSX file:
+                  parser error
+                EOEXPECTEDERRORMSG
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ticket/replicator/file_transformer_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "ticket/replicator/file_transformer"
+
+module Ticket
+  class Replicator
+    class FileTransformer
+      RSpec.describe FileTransformer do
+        let(:transformer) { described_class.send(:new, "source.csv", "transformed.csv") }
+
+        describe ".run_on" do
+          it "transforms the given file" do
+            expect(described_class).to receive(:run_class).with("file.csv").and_return(described_class)
+            expect(described_class).to receive(:new).with("file.csv", "transformed.csv").and_return(transformer)
+            expect(transformer).to receive(:run)
+
+            described_class.run_on("file.csv", "transformed.csv")
+          end
+        end
+
+        describe ".run_class" do
+          it { expect(described_class.run_class("foo_bar.csv")).to eq(FileTransformer::ForCSV) }
+          it { expect(described_class.run_class("foo_bar.xlsx")).to eq(FileTransformer::ForXLSX) }
+        end
+
+        describe "#run" do
+          let(:transformed_csv_writer) { double("csv") }
+
+          it "transforms the given file" do
+            expect(CSV).to receive(:open).with("transformed.csv", "wb", force_quotes: true)
+                                         .and_yield(transformed_csv_writer)
+
+            allow(transformer).to receive_messages(transformed_headers: :a_header)
+            allow(transformer).to receive_messages(transformed_rows: %i[a_row another_row])
+
+            expect(transformed_csv_writer).to receive(:<<).with(:a_header)
+            expect(transformed_csv_writer).to receive(:<<).with(:a_row)
+            expect(transformed_csv_writer).to receive(:<<).with(:another_row)
+
+            transformer.run
+          end
+        end
+
+        describe "#transformed_headers" do
+          it "returns the headers" do
+            expect(transformer.transformed_headers).to eq(%w[ID Status Resolution Priority Team Summary])
+          end
+        end
+
+        describe "#transformed_rows" do
+          before do
+            allow(transformer).to receive_messages(extracted_rows: %i[a_row another_row])
+          end
+
+          it "returns the rows" do
+            allow(RowTransformer).to receive(:run_on).with(:a_row).and_return(:a_tranformed_row)
+            allow(RowTransformer).to receive(:run_on).with(:another_row).and_return(:another_transformed_row)
+
+            expect(transformer.transformed_rows).to eq(%i[a_tranformed_row another_transformed_row])
+          end
+
+          context "when a row transformation error occurs" do
+            before do
+              allow(RowTransformer).to receive(:run_on).with(:a_row).and_return(:a_tranformed_row)
+
+              allow(RowTransformer)
+                .to receive(:run_on).with(:another_row)
+                                    .and_raise(TransformError, "transformation error")
+            end
+
+            it "raises an error message including the file name and line number of the row that was processed" do
+              expect { transformer.transformed_rows }.to raise_error(TransformError, <<~EOEXPECTEDERRORMSG)
+                source.csv:3: error while transforming row:
+                transformation error:
+                :another_row
+              EOEXPECTEDERRORMSG
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ticket/replicator/jira_project_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "ticket/replicator/jira_project"
+
+module Ticket
+  class Replicator
+    RSpec.describe JiraProject do
+      let(:project) { described_class.new(jira_auto_tool) }
+      let(:jira_auto_tool) { instance_double(Jira::Auto::Tool, jira_client: jira_client) }
+      let(:jira_client) { instance_double(JIRA::Client) }
+      let(:jira_client_project) { instance_double(JIRA::Resource::Project) }
+      let(:replicated_tickets) { 4.times.collect { instance_double(JIRA::Resource::Issue) } }
+
+      describe "#delete_all_tickets_from_the_expected_type" do
+        it do
+          allow(project).to receive(:replicated_tickets).and_return(replicated_tickets)
+          expect(replicated_tickets).to all(receive(:delete))
+
+          project.delete_all_tickets_from_the_expected_type
+        end
+      end
+
+      describe "#project_key" do
+        it do
+          expect(ENV).to receive(:fetch).with("TICKET_REPLICATOR_JIRA_PROJECT_KEY").and_return("PROJKEY")
+
+          expect(project.project_key).to eq("PROJKEY")
+        end
+      end
+
+      describe "#ticket_type_name" do
+        it do
+          expect(ENV).to receive(:fetch).with("TICKET_REPLICATOR_JIRA_TICKET_TYPE_NAME").and_return("Ticket Type Name")
+
+          expect(project.ticket_type_name).to eq("Ticket Type Name")
+        end
+      end
+
+      describe "#all_tickets" do
+        before do
+          expect(project).to receive(:all_jira_tickets).with(expected_ticket_jql).and_return(%i[a_ticket
+                                                                                                another_ticket])
+        end
+
+        context "when not specifying any query" do
+          let(:expected_ticket_jql) { "project = PROJECT_KEY" }
+
+          it "returns all project tickets" do
+            expect(project).to receive(:project_key).and_return("PROJECT_KEY")
+
+            expect(project.all_tickets).to all be_a_kind_of(Ticket)
+          end
+        end
+
+        context "when providing a specific query" do
+          let(:expected_ticket_jql) { " a specific JQL query" }
+
+          it "uses the specified query" do
+            expect(project.all_tickets(expected_ticket_jql)).to all be_a_kind_of(Ticket)
+          end
+        end
+      end
+
+      describe "#replicated_tickets" do
+        let(:expected_replicated_ticket_jql) do
+          <<-EOJQL
+            project = PROJKEY
+        AND issuetype = "Bug"
+          EOJQL
+        end
+
+        def build_non_replicated_ticket(summary)
+          double(Ticket, summary: summary, inspect: summary, replicated?: false)
+        end
+
+        def build_expected_ticket(source_id, summary)
+          double(Ticket, source_id: source_id, summary: summary, inspect: summary, replicated?: true)
+        end
+
+        let(:actual_replicated_tickets) do
+          [
+            build_expected_ticket("1", "SMAN-1 | a summary"),
+            build_expected_ticket("5", "SMAN-5 | a summary")
+          ]
+        end
+        let(:actual_tickets) do
+          [
+            build_non_replicated_ticket("a non replicated ticket"),
+            build_non_replicated_ticket("another non replicated ticket")
+          ] + actual_replicated_tickets
+        end
+
+        let(:expected_replicated_tickets) { %w[1 5].zip(actual_replicated_tickets).to_h }
+
+        it "fetches ticket pages" do
+          expect(project).to receive(:ticket_type_name).and_return("Bug")
+          expect(project).to receive(:project_key).and_return("PROJKEY")
+          expect(project).to receive(:all_tickets).with(expected_replicated_ticket_jql).and_return(actual_tickets)
+
+          expect(project.replicated_tickets).to eq(expected_replicated_tickets)
+        end
+      end
+
+      describe "#all_jira_tickets" do
+        let(:issue_accessor) { double("jira_client.Issue") }
+
+        let(:a_jql_query) { "a jql query" }
+
+        it "fetches ticket pages" do
+          expect(jira_client).to receive(:Issue).thrice.and_return(issue_accessor)
+
+          expect(issue_accessor).to receive(:jql).with(a_jql_query, { :max_results => 50, :start_at => 0 })
+                                                 .and_return(%i[first_ticket second_ticket third_ticket])
+
+          expect(issue_accessor).to receive(:jql).with(a_jql_query, { :max_results => 50, :start_at => 50 })
+                                                 .and_return(%i[forth_ticket fifth_ticket])
+
+          expect(issue_accessor).to receive(:jql).with(a_jql_query, { :max_results => 50, :start_at => 100 })
+                                                 .and_return([])
+
+          expect(project.send(:all_jira_tickets, a_jql_query))
+            .to eq(%i[first_ticket second_ticket third_ticket forth_ticket fifth_ticket])
+        end
+      end
+    end
+  end
+end

data/spec/ticket/replicator/replicated_summary_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "ticket/replicator/replicated_summary"
+
+RSpec.describe Ticket::Replicator::ReplicatedSummary do
+  describe ".build" do
+    let(:build_summary) { described_class.build("8192", "original summary") }
+
+    before do
+      expect(described_class).to receive(:new).with("8192", "original summary").and_call_original
+    end
+
+    it { expect(build_summary).to be_an_instance_of(described_class) }
+  end
+
+  describe ".match?" do
+    it { expect(described_class.match?("non replicated summary")).to be_falsy }
+    it { expect(described_class.match?("SMAN-1 | a replicated ticket summary")).to be_truthy }
+  end
+
+  describe ".parse" do
+    context "when the summary is not a valid replicated summary" do
+      it "raises error for a summary without a separator" do
+        expect { described_class.parse("SMAN-1234summary") }
+          .to raise_error(Ticket::Replicator::ReplicatedSummary::ParseError,
+                          %("SMAN-1234summary": missing expected prefix format: ) \
+                          "not matching #{Ticket::Replicator::ReplicatedSummary::TICKET_ID_PREFIX_REGEX.inspect}.")
+      end
+
+      it "raises error for summary with incorrect ticket prefix" do
+        expect { described_class.parse("TEST-1234 | summary") }
+          .to raise_error(Ticket::Replicator::ReplicatedSummary::ParseError)
+      end
+
+      it "raises error for empty summary" do
+        expect { described_class.parse("") }
+          .to raise_error(Ticket::Replicator::ReplicatedSummary::ParseError)
+      end
+    end
+
+    context "when the summary is a valid replicated summary" do
+      let(:parsed_summary) { described_class.parse("SMAN-1045 | another summary") }
+
+      before do
+        expect(described_class).to receive(:new).with("1045", "another summary").and_call_original
+      end
+
+      it { expect(parsed_summary).to be_an_instance_of(described_class) }
+    end
+  end
+
+  describe ".jql_pattern" do
+    it { expect(described_class.jql_pattern).to eq("SMAN-% | ") }
+  end
+
+  describe "fields" do
+    let(:replicated_summary) { described_class.send(:new, "9005", "some summary") }
+
+    describe "#source_summary" do
+      it { expect(replicated_summary.source_summary).to eq("some summary") }
+    end
+
+    describe "#source_id" do
+      it { expect(replicated_summary.source_id).to eq("9005") }
+    end
+    describe "#to_s" do
+      it { expect(replicated_summary.to_s).to eq("SMAN-9005 | some summary") }
+    end
+  end
+end