jira-auto-tool 0.1.1

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "jira/auto/tool/field"
+
+module Jira
+  module Auto
+    class Tool
+      RSpec.describe Jira::Auto::Tool::Field do
+        let(:field) { described_class.new(jira_client, jira_field) }
+
+        let(:jira_client) { jira_resource_double(JIRA::Client) }
+
+        let(:jira_field) do
+          jira_resource_double(
+            JIRA::Resource::Field,
+            name: "Field Name",
+            schema: { "type" => "string" },
+            id: "customfield_12345"
+          )
+        end
+
+        describe "#initialize" do
+          it "assigns jira_client" do
+            expect(field.jira_client).to eq(jira_client)
+          end
+
+          it "assigns jira_field" do
+            expect(field.jira_field).to eq(jira_field)
+          end
+        end
+
+        describe "#name" do
+          it "returns the field name" do
+            expect(field.name).to eq("Field Name")
+          end
+        end
+
+        describe "#type" do
+          it "returns the field type" do
+            expect(field.type).to eq("string")
+          end
+        end
+
+        describe "#id" do
+          it "returns the field id" do
+            expect(field.id).to eq("customfield_12345")
+          end
+        end
+
+        # TODO
+        describe "#values" do
+          let(:field_options) { [instance_double(FieldOption)] }
+
+          it "fetches the field values" do
+            allow(RequestBuilder::FieldOptionFetcher)
+              .to receive(:fetch_field_options).with(field).and_return(field_options)
+
+            expect(field.values).not_to be_empty
+          end
+        end
+
+        describe "#field_context" do
+          let(:logger) { instance_double(Logger) }
+
+          before do
+            allow(field)
+              .to receive_messages(field_contexts: %i[first_context second_context third_context],
+                                   log: logger)
+          end
+
+          it "returns the first context associated to a field and warns about multiple contexts" do
+            expect(logger).to receive(:warn)
+
+            expect(field.field_context).to eq(:first_context)
+          end
+        end
+
+        describe "#field_contexts" do
+          before do
+            allow(RequestBuilder::FieldContextFetcher)
+              .to receive_messages(fetch_field_contexts: %i[first_context second_context third_context])
+          end
+
+          it { expect(field.field_contexts).to eq(%i[first_context second_context third_context]) }
+        end
+
+        # TODO: - implement and maybe create a shared example to simplfy and reuse
+        describe "#<=>" do
+          def build_field(name, type, id)
+            # descr
+          end
+
+          it { expect(true).to be_truthy }
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/helpers/environment_based_value_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+module Jira
+  module Auto
+    class Tool
+      module Helpers
+        module EnvironmentBasedValue
+          RSpec.describe "EnvironmentBasedValue" do
+            context "when condition" do
+              it "succeeds" do
+                expect(true).to be_truthy # TODO
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/helpers/option_parser_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "jira/auto/tool/helpers/option_parser"
+
+RSpec.describe OptionParser do
+  let(:option_parser) { described_class.new([]) }
+
+  describe ".section_header" do
+    it do
+      expect(option_parser).to receive(:on).with(<<~EOSB)
+
+        a section name:
+        ---------------
+      EOSB
+
+      option_parser.section_header("a section name")
+    end
+  end
+end

data/spec/jira/auto/tool/helpers/overridable_time_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/helpers/overridable_time"
+
+module Jira
+  module Auto
+    class Tool
+      module Helpers
+        class OverridableTime
+          RSpec.describe OverridableTime do
+            describe ".now" do
+              let(:time_from_now) { Time.new(2025, 1, 1, 16, 32, 0, "UTC") }
+
+              it "returns the current date time" do
+                allow(Time).to receive_messages(now: time_from_now)
+
+                expect(described_class.now).to eq(time_from_now)
+              end
+
+              context "when the current date time is overridden" do
+                before do
+                  @previous_date_override = ENV.fetch("JAT_CURRENT_DATE_TIME", nil)
+                end
+
+                after do
+                  ENV["JAT_CURRENT_DATE_TIME"] = @previous_date_override
+                end
+
+                let(:overridden_date_time_string) { "2024-04-16 16:32 UTC" }
+
+                it "can be overridden using the JAT_CURRENT_DATE_TIME environment variable (e.g., for testing)" do
+                  ENV["JAT_CURRENT_DATE_TIME"] = overridden_date_time_string
+
+                  expect(described_class.now).to eq(Time.parse(overridden_date_time_string))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/helpers/pagination_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/helpers/pagination"
+
+class PaginatedObjectFetcher
+  def fetch_objects(pagination_options) end
+end
+
+RSpec.describe Jira::Auto::Tool::Helpers::Pagination do
+  describe ".fetch_all_object_pages" do
+    let(:object) { PaginatedObjectFetcher.new }
+
+    shared_examples "paginated request" do |parameter_naming_convention|
+      describe "#build_pagination_options" do
+        it "respects the parameter naming convention" do
+          expect(described_class.build_pagination_options(parameter_naming_convention, 50, 0))
+            .to eq(expected_build_pagination_options)
+        end
+      end
+
+      let(:object_pages_to_return) do
+        [
+          %w[object_1 object_2],
+          %w[object_3 object_4],
+          %w[object_5],
+          %w[]
+        ]
+      end
+
+      it "deals with JIRA::Resource pagination" do
+        expected_multi_page_options.zip(object_pages_to_return).each do
+        |expected_pagination_options, object_page_to_return|
+
+          allow(object).to receive(:fetch_objects).with(expected_pagination_options).and_return(object_page_to_return)
+        end
+
+        expect(described_class.fetch_all_object_pages(parameter_naming_convention) do |pagination_options|
+          object.fetch_objects(pagination_options)
+        end)
+          .to eq(%w[object_1 object_2 object_3 object_4 object_5])
+      end
+    end
+
+    context "when :snake_case parameter naming convention used" do
+      let(:page_keyset) { %i[start_at max_results] }
+      let(:expected_build_pagination_options) { { max_results: 50, start_at: 0 } }
+
+      let(:expected_multi_page_options) do
+        [{ max_results: 50, start_at: 0 },
+         { max_results: 50, start_at: 50 },
+         { max_results: 50, start_at: 100 },
+         { max_results: 50, start_at: 150 }]
+      end
+
+      it_behaves_like "paginated request", :snake_case
+    end
+
+    context "when :camelCase parameter naming convention used" do
+      let(:page_keyset) { %i[startAt maxResults] }
+      let(:expected_build_pagination_options) { { maxResults: 50, startAt: 0 } }
+
+      let(:expected_multi_page_options) do
+        [{ maxResults: 50, startAt: 0 },
+         { maxResults: 50, startAt: 50 },
+         { maxResults: 50, startAt: 100 },
+         { maxResults: 50, startAt: 150 }]
+      end
+
+      it_behaves_like "paginated request", :camelCase
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "jira/auto/tool/jira_http_options"
+
+module Jira
+  module Auto
+    class Tool
+      module JiraHttpOptions
+        RSpec.describe JiraHttpOptions do
+          describe ".add" do
+            let(:tool) { instance_double(Tool) }
+            let(:parser) { OptionParser.new }
+
+            before { described_class.add(tool, parser) }
+
+            # TODO: define proper tests
+            def expect_option_use_to_be_valid(option_use_with_args)
+              expect do
+                parser.parse([option_use_with_args])
+              end.not_to raise_error
+            end
+
+            it { expect_option_use_to_be_valid(["--jira-http-debug"]) }
+            it { expect_option_use_to_be_valid(["--jira-http-debug=false"]) }
+            it { expect_option_use_to_be_valid(["--no-jira-http-debug"]) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/next_sprint_creator"
+
+module Jira
+  module Auto
+    class Tool
+      RSpec.describe NextSprintCreator do
+        let(:tool) { instance_double(Tool) }
+        let(:last_sprint_name) { "ART_Team_24.4.5" }
+        let(:last_sprint_index_in_quarter) { 5 }
+        let(:last_sprint_start) { "2024-12-27 13:00:00 UTC" }
+        let(:last_sprint_end) { "2024-12-31 13:00:00 UTC" }
+
+        def last_sprint
+          instance_double(Sprint, tool: tool,
+                                  name: last_sprint_name,
+                                  start_date: Time.parse(last_sprint_start),
+                                  end_date: Time.parse(last_sprint_end),
+                                  name_prefix: "ART_Team",
+                                  length_in_days: 4,
+                                  index_in_quarter: last_sprint_index_in_quarter,
+                                  state: "closed",
+                                  origin_board_id: 512)
+        end
+
+        def next_sprint_creator_instance
+          described_class.new(last_sprint)
+        end
+
+        describe ".create_sprint_following" do
+          RSpec.shared_examples "a next sprint creator" do |expected|
+            it "requests the sprint creation with the expected attributes" do
+              allow(RequestBuilder::SprintCreator).to receive(:create_sprint)
+
+              described_class.create_sprint_following(last_sprint)
+
+              expect(RequestBuilder::SprintCreator)
+                .to have_received(:create_sprint)
+                .with(tool, 512,
+                      { name: expected[:next_sprint_name],
+                        start_date: Time.parse(expected[:next_sprint_start]).utc.to_s,
+                        length_in_days: 4 })
+            end
+          end
+
+          context "when next sprint is in the same quarter" do
+            it_behaves_like "a next sprint creator", { next_sprint_name: "ART_Team_24.4.6",
+                                                       next_sprint_start: "2024-12-31 13:00:00 UTC" }
+          end
+
+          context "when next sprint is in the coming year" do
+            let(:last_sprint_start) { "2024-12-31 13:00:00 UTC" }
+            let(:last_sprint_end) { "2025-01-03 13:00:00 UTC" }
+
+            it_behaves_like "a next sprint creator",
+                            { next_sprint_name: "ART_Team_25.1.1", next_sprint_start: "2025-01-03 13:00:00 UTC" }
+          end
+
+          context "when the current sprint starts locally at midnight and UTC is not yet in the new year" do
+            let(:last_sprint_name) { "ART_Team_25.1.1" }
+            let(:last_sprint_start) { "2025-01-01 00:00:00 +01:00" }
+            let(:last_sprint_end) { "2025-01-03 00:00:00 +01:00" }
+            let(:last_sprint_index_in_quarter) { 1 }
+
+            it_behaves_like "a next sprint creator",
+                            { next_sprint_name: "ART_Team_25.1.2", next_sprint_start: "2025-01-03 00:00:00 +01:00" }
+          end
+        end
+
+        describe "#same_quarter?" do
+          it { expect(next_sprint_creator_instance.same_quarter?).to be true }
+        end
+
+        describe "#next_sprint_start_date" do
+          it { expect(next_sprint_creator_instance.next_sprint_start_date).to eq(Time.parse("2024-12-31 13:00 UTC")) }
+        end
+
+        describe "#next_sprint_length_in_days" do
+          it { expect(next_sprint_creator_instance.next_sprint_length_in_days).to eq(4) }
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/performer/option_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "active_support"
+require "active_support/core_ext/string/inflections"
+require "jira/auto/tool/performer/options"
+
+module Jira
+  module Auto
+    class Tool
+      class Performer
+        module Options
+          RSpec.describe Options do
+            describe ".add" do
+              let(:tool) { instance_double(Tool) }
+              let(:parser) { OptionParser.new }
+
+              shared_examples "a performer" do |option_use_with_args, performer_class, *expected_args|
+                let(:performer_instance) { instance_double(performer_class, run: nil) }
+
+                before do
+                  allow(performer_class).to receive_messages(new: performer_instance)
+                end
+
+                it "adds a parser option to process #{option_use_with_args}" do
+                  expect do
+                    described_class.add(tool, parser)
+                    parser.parse([option_use_with_args])
+                  end.not_to raise_error
+
+                  expect(performer_class).to have_received(:new).with(tool, *expected_args)
+                  expect(performer_instance).to have_received(:run)
+                end
+              end
+
+              it_behaves_like "a performer", "--sprint-add=25.3.1,4",
+                              PlanningIncrementSprintCreator, "25.3.1", 4
+
+              it_behaves_like "a performer", "--sprint-align-time-in-dates=12:00 UTC",
+                              SprintTimeInDatesAligner, Time.parse("12:00 UTC")
+
+              ["--quarterly-sprint-rename", "--qsr"].each do |option|
+                it_behaves_like "a performer", "#{option}=old_name,new_name",
+                                QuarterlySprintRenamer, "old_name", "new_name"
+              end
+
+              it_behaves_like "a performer", "--sprint-update-end-date=regex,new_end_date",
+                              SprintEndDateUpdater, "regex", "new_end_date"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/performer/planning_increment_sprint_creator_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "jira/auto/tool/performer/planning_increment_sprint_creator"
+
+module Jira
+  module Auto
+    class Tool
+      class Performer
+        class PlanningIncrementSprintCreator
+          RSpec.describe PlanningIncrementSprintCreator do
+            let(:updater) { described_class.new(tool, "25.3.1", 4) }
+            let(:tool) { instance_double(Tool) }
+
+            def get_date(date_string)
+              Time.parse(date_string)
+            end
+
+            describe "#create_sprint_for" do
+              let(:last_sprint) do
+                instance_double(Sprint, origin_board_id: 64,
+                                        end_date: get_date("2025-02-16 15:06"), length_in_days: 4)
+              end
+
+              it "creates a sprint" do
+                expect(RequestBuilder::SprintCreator).to receive(:create_sprint).with(
+                  tool, 64, name: "Food_Restaurant_25.3.1",
+                            start_date: get_date("2025-02-16 15:06"), length_in_days: 4
+                )
+
+                updater.create_sprint_for(last_sprint, "Food_Restaurant_25.3.1")
+              end
+            end
+
+            describe "#act_on_sprints_for_sprint_prefix" do
+              def get_sprint(name, attributes)
+                instance_double(Sprint, name: name, to_s: name, **attributes)
+              end
+
+              let(:last_sprint) { get_sprint "Food_Delivery_25.2.1", end_date: "2025-02-16 12:45", length_in_days: 10 }
+
+              let(:sprint_prefix) { instance_double(Sprint::Prefix, name: "Food_Delivery", last_sprint: last_sprint) }
+
+              # rubocop:disable RSpec/MultipleExpectations
+              it "creates the expected number of sprints with the expected names" do
+                expect(updater).to receive(:create_sprint_for).ordered.with(last_sprint, "Food_Delivery_25.3.1")
+                expect(updater).to receive(:create_sprint_for).ordered.with(nil, "Food_Delivery_25.3.2")
+                expect(updater).to receive(:create_sprint_for).ordered.with(nil, "Food_Delivery_25.3.3")
+                expect(updater).to receive(:create_sprint_for).ordered.with(nil, "Food_Delivery_25.3.4")
+                expect(sprint_prefix).to receive(:<<).exactly(4).times
+
+                updater.act_on_sprints_for_sprint_prefix(sprint_prefix)
+              end
+              # rubocop:enable RSpec/MultipleExpectations
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/performer/prefix_sprint_updater_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/performer/prefix_sprint_updater"
+
+module Jira
+  module Auto
+    class Tool
+      class Performer
+        class PrefixSprintUpdater
+          RSpec.describe PrefixSprintUpdater do
+            let(:tool) { instance_double(Tool, unclosed_sprint_prefixes: sprint_prefixes) }
+            let(:updater) { described_class.new(tool) }
+
+            let(:sprint_prefixes) { %i[one_sprint_prefix another_sprint_prefix] }
+
+            describe "#sprint_prefixes" do
+              it { expect(updater.sprint_prefixes).to eq(sprint_prefixes) }
+            end
+
+            describe "#run" do
+              it "act on the sprints for each sprint prefix" do
+                allow(updater).to receive_messages(sprint_prefixes: sprint_prefixes,
+                                                   act_on_sprints_for_sprint_prefix: nil)
+
+                updater.run
+
+                expect(updater).to have_received(:act_on_sprints_for_sprint_prefix).exactly(2).times
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end