jira-auto-tool 0.1.1

data/spec/jira/auto/tool/request_builder/get_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/request_builder/get"
+
+module Jira
+  module Auto
+    class Tool
+      class RequestBuilder
+        RSpec.describe Get do
+          let(:jira_client) { instance_double(JIRA::Client) }
+          let(:request_builder) { described_class.new(jira_client) }
+
+          describe "#request_payload" do
+            it "returns nil" do
+              expect(request_builder.request_payload).to be_nil
+            end
+          end
+
+          describe "#http_verb" do
+            it "returns :get" do
+              expect(request_builder.http_verb).to eq(:get)
+            end
+          end
+
+          describe "#expected_response" do
+            it "returns 200" do
+              expect(request_builder.expected_response).to eq(200)
+            end
+          end
+
+          describe "#request_headers" do
+            it "returns nil" do
+              expect(request_builder.request_headers).to be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/request_builder/sprint_creator_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "jira/auto/tool/request_builder/sprint_state_updater"
+
+module Jira
+  module Auto
+    class Tool
+      class RequestBuilder
+        RSpec.describe SprintCreator do
+          let(:sprint_creator_instance) { described_class.new(jira_client, 32, attributes) }
+          let(:attributes) { { name: "a_name", start_date: "2024-12-19 13:16 UTC", length_in_days: 14 } }
+
+          let(:jira_client) { instance_spy(JIRA::Client, options: { context_path: :a_context_path }).as_null_object }
+          let(:tool) { instance_double(Tool, jira_client: jira_client) }
+
+          it { expect(sprint_creator_instance.send(:request_path)).to eq("/rest/agile/1.0/sprint") }
+
+          it { expect(sprint_creator_instance.send(:http_verb)).to eq(:post) }
+
+          it { expect(sprint_creator_instance.send(:expected_response)).to eq(201) }
+
+          def get_date(date_string)
+            Time.parse(date_string)
+          end
+
+          describe "#start_date" do
+            let(:actual_start_date) { sprint_creator_instance.send(:start_date) }
+
+            context "when no start date is provided" do
+              let(:attributes) { {} }
+
+              it { expect(actual_start_date).to be_nil }
+            end
+
+            context "when a start date is an empty string" do
+              let(:attributes) { { start_date: "" } }
+
+              it { expect(actual_start_date).to be_nil }
+            end
+
+            context "when a start date is provided" do
+              let(:attributes) { { start_date: "2024-12-19 13:16 UTC" } }
+
+              it { expect(actual_start_date).to eq(get_date("2024-12-19 13:16 UTC")) }
+            end
+          end
+
+          describe "#end_date" do
+            let(:actual_end_date) { sprint_creator_instance.send(:end_date) }
+
+            context "when no end date is provided" do
+              let(:attributes) { {} }
+
+              it { expect(actual_end_date).to be_nil }
+            end
+
+            context "when end date is an empty string" do
+              let(:attributes) { { end_date: "" } }
+
+              it { expect(actual_end_date).to be_nil }
+            end
+
+            context "when no end date specified and start date with length in days are provided" do
+              let(:attributes) { { start_date: "2024-12-19 13:16 UTC", length_in_days: 4 } }
+
+              it { expect(actual_end_date).to eq(get_date("2024-12-23 13:16 UTC")) }
+            end
+
+            context "when no end date is an empty string and start date with length in days are provided" do
+              let(:attributes) { { end_date: "", start_date: "2024-12-19 13:16 UTC", length_in_days: 4 } }
+
+              it { expect(actual_end_date).to eq(get_date("2024-12-23 13:16 UTC")) }
+            end
+
+            context "when end date is provided" do
+              let(:attributes) { { end_date: "2024-12-19 13:16 UTC" } }
+
+              it { expect(actual_end_date).to eq(get_date("2024-12-19 13:16 UTC")) }
+            end
+
+            context "when end date and length in days are provided" do
+              let(:attributes) { { end_date: "2024-12-19 13:16 UTC", length_in_days: 7 } }
+
+              it do
+                expect { actual_end_date }
+                  .to raise_error(ArgumentError,
+                                  "Should not provide both :end_date (2024-12-19 13:16:00 UTC) " \
+                                  "and :length_in_days (7)!")
+              end
+            end
+          end
+
+          describe "#length_in_days" do
+            let(:length_in_days) { sprint_creator_instance.send(:length_in_days) }
+
+            context "when no :start_date provided" do
+              let(:attributes) { { length_in_days: 5 } }
+
+              it do
+                expect { length_in_days }
+                  .to raise_error(ArgumentError, "Should provide :start_date in order to use :length_in_days!")
+              end
+            end
+
+            context "when :start_date provided" do
+              let(:start_date_attributes) { { start_date: "2024-12-19 13:16 UTC" } }
+
+              context "when no length in days is provided" do
+                let(:attributes) { start_date_attributes.merge({}) }
+
+                it { expect(length_in_days).to be_nil }
+              end
+
+              context "when length in days is an empty string" do
+                let(:attributes) { start_date_attributes.merge({ length_in_days: "" }) }
+
+                it { expect(length_in_days).to be_nil }
+              end
+
+              context "when length in days is a number" do
+                let(:attributes) { start_date_attributes.merge({ length_in_days: 28 }) }
+
+                it { expect(length_in_days).to eq(28) }
+              end
+
+              context "when length in days is number in a string" do
+                let(:attributes) { start_date_attributes.merge({ length_in_days: "21" }) }
+
+                it { expect(length_in_days).to eq(21) }
+              end
+
+              context "when length in days is improper integer number in a string" do
+                let(:attributes) { start_date_attributes.merge({ length_in_days: "21xx" }) }
+
+                it { expect { length_in_days }.to raise_error(ArgumentError, 'invalid value for Integer(): "21xx"') }
+              end
+            end
+          end
+
+          it do
+            expect(sprint_creator_instance.send(:request_payload))
+              .to eq({
+                       name: "a_name",
+                       startDate: "2024-12-19T13:16:00Z",
+                       endDate: "2025-01-02T13:16:00Z",
+                       originBoardId: 32
+                     })
+          end
+
+          describe ".create_sprint" do
+            let(:actual_response) do
+              instance_double(Net::HTTPResponse, code: "201", body: { "id" => 512 }.to_json)
+            end
+
+            let(:actual_sprints) do
+              [
+                instance_spy(JIRA::Resource::Sprint, id: 256),
+                instance_spy(JIRA::Resource::Sprint, id: 512)
+              ]
+            end
+
+            it "returns the object corresponding to the created sprint" do
+              allow(jira_client).to receive_messages(send: actual_response)
+              allow(jira_client).to receive_messages(Sprint: actual_sprints)
+              allow(actual_sprints).to receive(:find).with(512).and_return(actual_sprints.last)
+
+              expect(described_class.create_sprint(tool, 32,
+                                                   { name: "a_name",
+                                                     start_date: "2024-12-19 13:16 UTC",
+                                                     length_in_days: 14 }))
+                .to be_a(Sprint)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/request_builder/sprint_state_updater_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "jira/auto/tool/request_builder/sprint_state_updater"
+
+RSpec.describe Jira::Auto::Tool::RequestBuilder::SprintStateUpdater do
+  let(:sprint_creator_instance) { described_class.new(jira_client, sprint: sprint_to_update, new_state: "closed") }
+
+  let(:sprint_to_update) do
+    instance_spy(JIRA::Resource::Sprint, id: 12_345, attrs: { id: 12_345, state: "open" })
+  end
+
+  let(:jira_client) { instance_spy(JIRA::Client, options: { context_path: :a_context_path }).as_null_object }
+
+  it { expect(sprint_creator_instance.send(:request_path)).to eq("/rest/agile/1.0/sprint/12345") }
+
+  it { expect(sprint_creator_instance.send(:http_verb)).to eq(:put) }
+
+  it do
+    expect(sprint_creator_instance.send(:request_payload))
+      .to eq({
+               id: 123_45,
+               self: nil,
+               name: nil,
+               startDate: nil,
+               endDate: nil,
+               originBoardId: nil,
+               state: "closed"
+             })
+  end
+end

data/spec/jira/auto/tool/request_builder_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+RSpec.describe Jira::Auto::Tool::RequestBuilder do
+  describe "#run" do
+    let(:request_builder) { described_class.new(jira_client) }
+
+    let(:jira_client) do
+      jira_client = instance_spy(JIRA::Client).as_null_object
+      allow(JIRA::Client).to receive_messages(new: jira_client)
+      jira_client
+    end
+
+    let(:expected_response) do
+      instance_double(Net::HTTPResponse, code: 200, body: "sprint updated successfully")
+    end
+
+    describe "#context_path" do
+      before do
+        allow(jira_client).to receive_messages(options: { context_path: "/path/to/context" })
+      end
+
+      it { expect(request_builder.send(:context_path)).to eq("/path/to/context") }
+    end
+
+    describe "#request_path_with_context" do
+      before do
+        allow(request_builder).to receive_messages(context_path: "/path/to/context", request_path: "/request/path")
+      end
+
+      it { expect(request_builder.send(:request_path_with_context)).to eq("/path/to/context/request/path") }
+    end
+
+    describe "#run" do
+      before do
+        allow(jira_client).to receive_messages(put: expected_response)
+
+        allow(request_builder).to receive_messages(
+          http_verb: :put,
+          context_path: "/path/to/context", request_path: "/request/path",
+          request_payload: { some_payload: "value" },
+          expected_response: 200,
+          error_message_prefix: "Error updating auto state",
+          success_message_prefix: "Sprint state updated successfully"
+        )
+      end
+
+      it "sends the expected request" do
+        request_builder.run
+
+        expect(jira_client).to have_received(:put)
+          .with("/path/to/context/request/path",
+                { some_payload: "value" }.to_json,
+                { "Content-Type" => "application/json" })
+      end
+
+      it "returns the response" do
+        allow(request_builder).to receive_messages(send_request: expected_response, expected_response: 200)
+
+        expect(request_builder.run).to eq(expected_response)
+      end
+    end
+
+    describe ".build_request_args" do
+      it "removes payload as an argument if it is nil" do
+        allow(request_builder).to receive_messages(request_headers: :some_headers)
+
+        expect(request_builder.send(:build_request_args, "/request/path", nil)).to eq(["/request/path", :some_headers])
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/sprint/name_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/sprint/name"
+
+module Jira
+  module Auto
+    class Tool
+      class Sprint
+        RSpec.describe Name do
+          describe ".parse" do
+            let(:parsed_name) { described_class.parse("ART_Team_24.4.5") }
+
+            it { expect(parsed_name.prefix).to eq("ART_Team") }
+            it { expect(parsed_name.year).to eq(24) }
+            it { expect(parsed_name.quarter).to eq(4) }
+            it { expect(parsed_name.index_in_quarter).to eq(5) }
+            it { expect(parsed_name.planning_interval).to eq([24, 4]) }
+
+            it "raise an error if the sprint name is not according to convention" do
+              expect { described_class.parse("name ignoring naming convention") }
+                .to raise_error(Name::NameConventionError,
+                                "'name ignoring naming convention': " \
+                                "sprint name not matching #{Name::SPRINT_NAME_REGEX}!")
+            end
+          end
+
+          describe "#next_in_planning_interval" do
+            let(:parsed_name) { described_class.parse("ART_Team_25.2.1") }
+
+            it do
+              expect(parsed_name.next_in_planning_interval)
+                .to eq(described_class.new("ART_Team", 25, 2, 2))
+            end
+          end
+
+          # rubocop:disable RSpec/PredicateMatcher
+          describe ".respects_naming_convention?" do
+            it "returns true if the sprint name is according to convention" do
+              expect(described_class.respects_naming_convention?("ART_Team_24.4.5"))
+                .to be_truthy
+            end
+
+            it "returns false if the sprint name is not according to convention" do
+              expect(described_class.respects_naming_convention?("name ignoring naming convention"))
+                .to be_falsey
+            end
+          end
+          # rubocop:enable RSpec/PredicateMatcher
+
+          describe ".build" do
+            it "builds the expected name" do
+              expect(described_class.build("ART_Team", 25, 2, 3)).to eq("ART_Team_25.2.3")
+            end
+          end
+
+          describe "#new_with" do
+            it "builds the expected name" do
+              expect(described_class.new_with("ART_Team", "25.3.4"))
+                .to eq(described_class.new("ART_Team", 25, 3, 4))
+            end
+
+            it "fails if the sprint name is not according to convention" do
+              expect { described_class.new_with("ART_Team", "MALFORMED_SUFFIX") }
+                .to raise_error(
+                  Name::NameConventionError,
+                  "suffix not following convention 'MALFORMED_SUFFIX': " \
+                  "resulting sprint name 'ART_Team_MALFORMED_SUFFIX' not matching #{Name::SPRINT_NAME_REGEX}!"
+                )
+            end
+          end
+
+          describe "#<=>" do
+            let(:parsed_name) { described_class.parse("ART_Team_24.4.5") }
+
+            it { expect(parsed_name).to be > described_class.parse("ART_Team_24.4.1") }
+            it { expect(parsed_name).to eq described_class.parse("ART_Team_24.4.05") }
+            it { expect(parsed_name).to be < described_class.parse("ART_Team_24.4.10") }
+
+            context "when comparing to a sprint name not according to convention" do
+              it { expect(parsed_name).to be > "1st sprint" }
+              it { expect(parsed_name).to be < "name ignoring naming convention" }
+            end
+          end
+
+          describe "#comparison_values" do
+            let(:parsed_name) { described_class.parse("ART_Team_24.4.5") }
+
+            it { expect(parsed_name.send(:comparison_values, parsed_name)).to eq(["ART_Team", 24, 4, 5]) }
+
+            context "when sprint name not according to convention" do
+              it {
+                expect(parsed_name.send(:comparison_values,
+                                        "name not following conventions")).to eq(["name not following conventions"])
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/sprint/prefix_spec.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/sprint/prefix"
+require "jira/auto/tool/until_date"
+
+module Jira
+  module Auto
+    class Tool
+      class Sprint
+        RSpec.describe Prefix do
+          def new_prefix(name, sprints = [])
+            described_class.new(name, sprints)
+          end
+
+          describe "#name" do
+            it "returns the name of the prefix" do
+              expect(new_prefix("ART_Team").name).to eq("ART_Team")
+            end
+          end
+
+          describe "#sprints" do
+            it "is empty by default" do
+              expect(described_class.new("a_prefix").sprints).to be_empty
+            end
+
+            it "can be specified explicitly at creation" do
+              expect(new_prefix("ART_Another-Team", %w[sprint_1 sprint_2]).sprints)
+                .to eq(%w[sprint_1 sprint_2])
+            end
+
+            it "accepts new sprints" do
+              prefix = new_prefix("ART_Team")
+              prefix << :one_sprint
+              prefix << :another_sprint
+
+              expect(prefix.sprints).to eq(%i[another_sprint one_sprint])
+            end
+
+            context "when looking at the sprint order" do
+              let(:prefix) { new_prefix("ART_Team", %i[sprint_comes_2nd sprint_comes_1st]) }
+
+              it "has sorted sprints" do
+                expect(prefix.sprints).to eq(%i[sprint_comes_1st sprint_comes_2nd])
+              end
+
+              it "stays sorted when new sprints are added" do
+                prefix << :before_2nd_sprint
+                prefix << :before_1st_sprint
+
+                expect(prefix.sprints).to eq(%i[before_1st_sprint before_2nd_sprint sprint_comes_1st sprint_comes_2nd])
+              end
+            end
+          end
+
+          describe "#to_table_row" do
+            let(:prefix) { new_prefix("Food_Supply", []) }
+
+            let(:last_sprint) { instance_double(Sprint) }
+
+            before { allow(prefix).to receive_messages(last_sprint: last_sprint) }
+
+            it do
+              allow(last_sprint)
+                .to receive_messages(to_table_row:
+                                       [512, "Food_Supply_24.4.5", 4, "2024-12-27 13:00 UTC", "2024-12-31 13:00 UTC",
+                                        "Food Supply Team Board", :url_to_suppply_team_board, "FOOD"])
+
+              expect(prefix.to_table_row)
+                .to eq(["Food_Supply", 512, "Food_Supply_24.4.5", 4, "2024-12-27 13:00 UTC", "2024-12-31 13:00 UTC",
+                        "Food Supply Team Board", :url_to_suppply_team_board, "FOOD"])
+            end
+
+            it "can exclude the board information" do
+              allow(last_sprint)
+                .to receive(:to_table_row)
+                .with(without_board_information: true)
+                .and_return([512, "Food_Supply_24.4.5", 4, "2024-12-27 13:00 UTC", "2024-12-31 13:00 UTC"])
+
+              expect(prefix.to_table_row(without_board_information: true))
+                .to eq(["Food_Supply", 512, "Food_Supply_24.4.5", 4, "2024-12-27 13:00 UTC", "2024-12-31 13:00 UTC"])
+            end
+          end
+
+          describe ".to_table_row_header" do
+            it do
+              allow(Sprint)
+                .to receive_messages(to_table_row_header: ["Id", "Name", "Length In Days", "Start Date", "End Date",
+                                                           "Board Name", "Board UI URL", "Board Project Key"])
+
+              expect(described_class.to_table_row_header)
+                .to eq(["Sprint Prefix", "Last Sprint Id", "Last Sprint Name", "Length In Days",
+                        "Start Date", "End Date", "Board Name", "Board UI URL", "Board Project Key"])
+            end
+
+            it "can exclude the board information" do
+              allow(Sprint)
+                .to receive(:to_table_row_header).with(without_board_information: true)
+                                                 .and_return(["Id", "Name", "Length In Days", "Start Date", "End Date"])
+
+              expect(described_class.to_table_row_header(without_board_information: true))
+                .to eq(["Sprint Prefix", "Last Sprint Id", "Last Sprint Name", "Length In Days", "Start Date",
+                        "End Date"])
+            end
+          end
+
+          describe "#<=>" do
+            let(:art_team_prefix) { new_prefix("ART_Team", %w[sprint_1 sprint_2]) }
+
+            it { expect(art_team_prefix).to eq(new_prefix("ART_Team", %w[sprint_1 sprint_2])) }
+            it { expect(art_team_prefix).to be > new_prefix("ART_Team", %w[sprint_1]) }
+            it { expect(art_team_prefix).to be > new_prefix("ART_Team", %w[p1 p2]) }
+            it { expect(art_team_prefix).to be < new_prefix("ART_Team", %w[x1]) }
+            it { expect(art_team_prefix).to be < new_prefix("GreaterART_Team", []) }
+            it { expect(art_team_prefix).to be > new_prefix("AA_Team", []) }
+          end
+
+          describe "#add_sprint_following_last_one" do
+            context "when unclosed sprint are found" do
+              let(:actual_sprints) do
+                [
+                  "1st sprint",
+                  "last sprint",
+                  "2nd sprint"
+                ]
+              end
+
+              let(:prefix) { described_class.new("sprint", actual_sprints) }
+              let(:newly_added_sprint) { instance_double(Sprint, name: "sprint following last sprint") }
+
+              it "add a sprint for the sprint prefixes having at least one unclosed sprint" do
+                allow(NextSprintCreator)
+                  .to receive(:create_sprint_following).with("last sprint").and_return(newly_added_sprint)
+                allow(prefix).to receive_messages(:<< => nil)
+
+                prefix.add_sprint_following_last_one
+
+                expect(prefix).to have_received(:<<).with(newly_added_sprint)
+              end
+            end
+          end
+
+          describe "#quarterly_add_sprints_until" do
+            let(:until_date) { UntilDate.new("2024-05-15") }
+            let(:prefix) { described_class.new("name_prefix") }
+
+            it "adds no sprint if date is already covered" do
+              allow(prefix).to receive_messages(covered?: true, add_sprint_following_last_one: nil)
+
+              prefix.quarterly_add_sprints_until(until_date)
+
+              expect(prefix).not_to have_received(:add_sprint_following_last_one)
+            end
+
+            it "adds sprints until date is covered" do
+              allow(prefix).to receive(:covered?).and_return(false, false, true)
+              allow(prefix).to receive_messages(add_sprint_following_last_one: nil)
+
+              prefix.quarterly_add_sprints_until(until_date)
+
+              expect(prefix).to have_received(:add_sprint_following_last_one).exactly(:twice)
+            end
+          end
+
+          describe "#covered?" do
+            let(:last_sprint) do
+              instance_double(Sprint,
+                              start_date: Time.parse("2024-05-01 11:00 UTC"),
+                              end_date: Time.parse("2024-05-14 11:00 UTC"))
+            end
+
+            let(:prefix) { described_class.new("name_prefix") }
+
+            before { allow(prefix).to receive_messages(last_sprint: last_sprint) }
+
+            it "handles date anterior to last sprint" do
+              expect(prefix_has_covered?("2024-04-30 11:00 UTC")).to be true
+            end
+
+            it "handles date included in the last sprint" do
+              expect(prefix_has_covered?("2024-05-01 11:00 UTC")).to be true
+            end
+
+            it "handles time past to the last sprint end time on the same day" do
+              expect(prefix_has_covered?("2024-05-14 12:00 UTC")).to be false
+            end
+
+            it "handles date past to the last sprint day" do
+              expect(prefix_has_covered?("2024-05-15 11:00 UTC")).to be false
+            end
+
+            def prefix_has_covered?(date_string)
+              prefix.covered?(UntilDate.new(date_string))
+            end
+          end
+
+          describe "#last_sprint" do
+            it "returns the last sprint as per the sprint default sort criteria" do
+              prefix = new_prefix("ART_Team", %w[sprint_2 xx_last_sprint sprint_1 another_sprint1])
+
+              expect(prefix.last_sprint).to eq("xx_last_sprint")
+            end
+          end
+        end
+      end
+    end
+  end
+end