jira-auto-tool 0.1.1

data/spec/jira/auto/tool/performer/quarterly_sprint_renamer/next_name_generator_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "jira/auto/tool/performer/quarterly_sprint_renamer/next_name_generator"
+
+RSpec.describe Jira::Auto::Tool::Performer::QuarterlySprintRenamer::NextNameGenerator do
+  def parsed_name(sprint_name)
+    Jira::Auto::Tool::Sprint::Name.parse(sprint_name)
+  end
+
+  describe "#new_name_of_sprint_next_to_first_renamed_sprint" do
+    subject(:new_name) { next_name_generator.new_name_of_sprint_next_to_first_renamed_sprint }
+
+    let(:next_name_generator) do
+      described_class.new(original_name_of_first_renamed_sprint, name_of_first_renamed_sprint)
+    end
+
+    context "when pulling sprint into previous planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_23.2.1" }
+      let(:name_of_first_renamed_sprint) { "prefix_23.1.6" }
+
+      it("returns the original sprint name") { expect(new_name).to eq(parsed_name("prefix_23.2.1")) }
+    end
+
+    context "when renaming inside planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_23.2.1" }
+      let(:name_of_first_renamed_sprint) { "prefix_23.2.4" }
+
+      it { expect(new_name).to eq(parsed_name("prefix_23.2.5")) }
+    end
+
+    context "when pushing sprint into next planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_23.1.5" }
+      let(:name_of_first_renamed_sprint) { "prefix_23.2.2" }
+
+      it("returns the original sprint parsed name") { expect(new_name).to eq(parsed_name("prefix_23.2.3")) }
+    end
+  end
+
+  describe "#pulling_sprint_into_previous_planning_interval?" do
+    let(:next_name_generator) do
+      described_class.new(original_name_of_first_renamed_sprint, name_of_first_renamed_sprint)
+    end
+
+    context "when sprint goes to the preceding planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_26.1.1" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.2.1" }
+
+      it { expect(next_name_generator).to be_pulling_sprint_into_previous_planning_interval }
+    end
+
+    context "when sprint is renamed backward inside the current planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_26.1.4" }
+      let(:name_of_first_renamed_sprint) { "prefix_26.1.1" }
+
+      it { expect(next_name_generator).not_to be_pulling_sprint_into_previous_planning_interval }
+    end
+
+    context "when sprint is renamed forward inside the current planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_26.1.1" }
+      let(:name_of_first_renamed_sprint) { "prefix_26.1.4" }
+
+      it { expect(next_name_generator).not_to be_pulling_sprint_into_previous_planning_interval }
+    end
+
+    context "when sprint goes to the following planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_25.1.5" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.2.1" }
+
+      it { expect(next_name_generator).not_to be_pulling_sprint_into_previous_planning_interval }
+    end
+  end
+
+  describe "#next_name_in_planning_interval" do
+    let(:name_generator) { described_class.new(original_name_of_first_renamed_sprint, name_of_first_renamed_sprint) }
+    let(:next_names) { 4.times.collect { name_generator.next_name_in_planning_interval } }
+
+    context "when pulling to the previous planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_25.2.1" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.1.8" }
+
+      it "generates a new name consecutive to the previous one in the planning interval" do
+        expect(next_names).to eq(%w[prefix_25.2.1 prefix_25.2.2 prefix_25.2.3 prefix_25.2.4])
+      end
+    end
+
+    context "when renaming in the same planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_25.1.5" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.1.20" }
+
+      it "generates a new name consecutive to the previous one in the planning interval" do
+        expect(next_names).to eq(%w[prefix_25.1.21 prefix_25.1.22 prefix_25.1.23 prefix_25.1.24])
+      end
+    end
+
+    context "when pushing to the next planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_25.1.5" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.2.1" }
+
+      it "generates a new name consecutive to the previous one in the planning interval" do
+        expect(next_names).to eq(%w[prefix_25.2.2 prefix_25.2.3 prefix_25.2.4 prefix_25.2.5])
+      end
+    end
+  end
+
+  describe "#name_for" do
+    let(:name_generator) { described_class.new(original_name_of_first_renamed_sprint, name_of_first_renamed_sprint) }
+    let(:original_name_of_first_renamed_sprint) { "prefix_25.2.1" }
+    let(:name_of_first_renamed_sprint) { "prefix_25.1.8" }
+
+    context "when sprint name inside the planning interval" do
+      before do
+        allow(name_generator).to receive_messages(next_name_in_planning_interval: "next_name_in_planning_interval")
+      end
+
+      it { expect(name_generator.name_for("prefix_25.2.2")).to eq("next_name_in_planning_interval") }
+    end
+
+    context "when sprint name outside planning interval from first sprint to rename" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_25.1.5" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.1.20" }
+
+      it "the name stays unchanged" do
+        expect(name_generator.name_for("prefix_25.3.2")).to eq("prefix_25.3.2")
+      end
+    end
+  end
+
+  describe "#outside_planning_interval_of_sprint_next_to_first_renamed_sprint?" do
+    let(:name_generator) { described_class.new(original_name, new_name) }
+
+    def outside?(sprint_name)
+      name_generator.outside_planning_interval_of_sprint_next_to_first_renamed_sprint?(sprint_name)
+    end
+
+    context "when pulling sprint into previous planning interval" do
+      let(:original_name) { "prefix_25.2.1" }
+      let(:new_name) { "prefix_25.1.6" }
+
+      it { expect(outside?("prefix_25.1.3")).to be_truthy }
+      it { expect(outside?("prefix_25.2.1")).not_to be_truthy }
+      it { expect(outside?("prefix_25.2.3")).not_to be_truthy }
+      it { expect(outside?("prefix_25.3.1")).to be_truthy }
+      it { expect(outside?("prefix_25.3.2")).to be_truthy }
+      it { expect(outside?("prefix_25.4.2")).to be_truthy }
+      it { expect(outside?("prefix_26.1.1")).to be_truthy }
+    end
+
+    context "when sprint renamed inside planning interval" do
+      let(:original_name) { "prefix_25.2.5" }
+      let(:new_name) { "prefix_25.2.16" }
+
+      it { expect(outside?("prefix_25.1.5")).to be_truthy }
+      it { expect(outside?("prefix_25.2.1")).to be_falsy }
+      it { expect(outside?("prefix_25.2.20")).to be_falsy }
+      it { expect(outside?("prefix_25.3.2")).to be_truthy }
+      it { expect(outside?("prefix_25.4.2")).to be_truthy }
+      it { expect(outside?("prefix_26.1.1")).to be_truthy }
+    end
+
+    context "when pushing sprint into next planning interval" do
+      let(:original_name) { "prefix_25.1.5" }
+      let(:new_name) { "prefix_25.2.1" }
+
+      it { expect(outside?("prefix_25.1.5")).to be_truthy }
+      it { expect(outside?("prefix_25.2.1")).to be_falsy }
+      it { expect(outside?("prefix_25.2.3")).to be_falsy }
+      it { expect(outside?("prefix_25.3.1")).to be_truthy }
+      it { expect(outside?("prefix_25.3.2")).to be_truthy }
+      it { expect(outside?("prefix_25.4.2")).to be_truthy }
+      it { expect(outside?("prefix_26.1.1")).to be_truthy }
+    end
+  end
+end

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

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "jira/auto/tool/performer/quarterly_sprint_renamer"
+
+RSpec.describe Jira::Auto::Tool::Performer::QuarterlySprintRenamer do
+  let(:sprint_renamer) { described_class.new(tool, from_string, to_string) }
+  let(:tool) { instance_double(Jira::Auto::Tool) }
+  let(:from_string) { "25.1.5" }
+  let(:to_string) { "25.2.1" }
+
+  describe "#from_string_regex" do
+    it { expect(sprint_renamer.from_string_regex).to eq(/25\.1\.5/) }
+  end
+
+  describe "#to_string" do
+    it { expect(sprint_renamer.to_string).to eq("25.2.1") }
+  end
+
+  describe "#acton_sprints_for_sprint_prefix" do
+    def create_sprint(name)
+      instance_double(Jira::Auto::Tool::Sprint, name: name, rename_to: nil)
+    end
+
+    let(:one_sprint) { create_sprint("a sprint name") }
+    let(:another_sprint) { create_sprint("another sprint name") }
+
+    let(:sprints) { [one_sprint, another_sprint] }
+
+    let(:prefix) { instance_double(Jira::Auto::Tool::Sprint::Prefix, name: "Food_Delivery", sprints: sprints) }
+
+    before do
+      allow(sprint_renamer).to receive_messages(calculate_sprint_new_names: ["a new name", "another new name"])
+    end
+
+    it "renames each sprint" do
+      sprint_renamer.act_on_sprints_for_sprint_prefix(prefix)
+
+      expect(sprints).to all have_received(:rename_to)
+    end
+  end
+
+  describe "#calculate_sprint_new_names" do
+    let(:sprint_names) do
+      %w[
+        Food_Delivery_25.1.2
+        Food_Delivery_25.1.3
+        Food_Delivery_25.1.4
+        Food_Delivery_25.1.5
+        Food_Delivery_25.2.1
+        Food_Delivery_25.2.2
+        Food_Delivery_25.2.3
+        Food_Delivery_25.2.4
+        Food_Delivery_25.2.5
+      ]
+    end
+
+    context "when pulling a sprint into the previous planning interval" do
+      let(:from_string) { "25.2.1" }
+      let(:to_string) { "25.1.6" }
+
+      let(:expected_new_sprint_names) do
+        %w[
+          Food_Delivery_25.1.2
+          Food_Delivery_25.1.3
+          Food_Delivery_25.1.4
+          Food_Delivery_25.1.5
+          Food_Delivery_25.1.6
+          Food_Delivery_25.2.1
+          Food_Delivery_25.2.2
+          Food_Delivery_25.2.3
+          Food_Delivery_25.2.4
+        ]
+      end
+
+      it { expect(sprint_renamer.calculate_sprint_new_names(sprint_names)).to eq(expected_new_sprint_names) }
+    end
+
+    context "when renaming sprint forward inside planning interval" do
+      let(:from_string) { "25.2.1" }
+      let(:to_string) { "25.2.10" }
+
+      let(:expected_new_sprint_names) do
+        %w[
+          Food_Delivery_25.1.2
+          Food_Delivery_25.1.3
+          Food_Delivery_25.1.4
+          Food_Delivery_25.1.5
+          Food_Delivery_25.2.10
+          Food_Delivery_25.2.11
+          Food_Delivery_25.2.12
+          Food_Delivery_25.2.13
+          Food_Delivery_25.2.14
+        ]
+      end
+
+      it do
+        expect(sprint_renamer.calculate_sprint_new_names(["Food_Delivery_25.1.5"]))
+          .to eq(["Food_Delivery_25.1.5"])
+      end
+
+      it { expect(sprint_renamer.calculate_sprint_new_names(sprint_names)).to eq(expected_new_sprint_names) }
+    end
+
+    context "when renaming sprint backward inside planning interval" do
+      let(:from_string) { "25.2.10" }
+      let(:to_string) { "25.2.1" }
+
+      let(:sprint_names) do
+        %w[
+          Food_Delivery_25.1.2
+          Food_Delivery_25.1.3
+          Food_Delivery_25.1.4
+          Food_Delivery_25.1.5
+          Food_Delivery_25.2.10
+          Food_Delivery_25.2.11
+          Food_Delivery_25.2.12
+          Food_Delivery_25.2.13
+          Food_Delivery_25.2.14
+        ]
+      end
+
+      let(:expected_new_sprint_names) do
+        %w[
+          Food_Delivery_25.1.2
+          Food_Delivery_25.1.3
+          Food_Delivery_25.1.4
+          Food_Delivery_25.1.5
+          Food_Delivery_25.2.1
+          Food_Delivery_25.2.2
+          Food_Delivery_25.2.3
+          Food_Delivery_25.2.4
+          Food_Delivery_25.2.5
+        ]
+      end
+
+      it do
+        expect(sprint_renamer.calculate_sprint_new_names(["Food_Delivery_25.1.5"]))
+          .to eq(["Food_Delivery_25.1.5"])
+      end
+
+      it { expect(sprint_renamer.calculate_sprint_new_names(sprint_names)).to eq(expected_new_sprint_names) }
+    end
+
+    context "when pushing a sprint to the next planning interval" do
+      let(:expected_new_sprint_names) do
+        %w[
+          Food_Delivery_25.1.2
+          Food_Delivery_25.1.3
+          Food_Delivery_25.1.4
+          Food_Delivery_25.2.1
+          Food_Delivery_25.2.2
+          Food_Delivery_25.2.3
+          Food_Delivery_25.2.4
+          Food_Delivery_25.2.5
+          Food_Delivery_25.2.6
+        ]
+      end
+
+      it { expect(sprint_renamer.calculate_sprint_new_names(["Food_Delivery_25.1.5"])).to eq(["Food_Delivery_25.2.1"]) }
+
+      it { expect(sprint_renamer.calculate_sprint_new_names(sprint_names)).to eq(expected_new_sprint_names) }
+    end
+
+    context "when sprints exist beyond the immediate planning interval of the sprint" do
+      let(:from_string) { "25.2.1" }
+      let(:to_string) { "25.1.6" }
+
+      let(:sprint_names) do
+        %w[
+          Food_Delivery_25.1.5
+          Food_Delivery_25.2.1
+          Food_Delivery_25.2.2
+          Food_Delivery_25.3.1
+          Food_Delivery_25.3.2
+          Food_Delivery_25.3.3
+        ]
+      end
+
+      let(:expected_new_sprint_names) do
+        %w[
+          Food_Delivery_25.1.5
+          Food_Delivery_25.1.6
+          Food_Delivery_25.2.1
+          Food_Delivery_25.3.1
+          Food_Delivery_25.3.2
+          Food_Delivery_25.3.3
+        ]
+      end
+
+      it "does not rename those sprints" do
+        expect(sprint_renamer.calculate_sprint_new_names(sprint_names)).to eq(expected_new_sprint_names)
+      end
+    end
+
+    context "when multiple sprints are matching the first sprint to rename" do
+      let(:from_string) { "25.2.1" }
+      let(:to_string) { "25.1.6" }
+
+      let(:sprint_names) do
+        %w[
+          Food_Delivery_25.1.5
+          Food_Delivery_25.2.1
+          Food_Delivery_25.2.1
+          Food_Delivery_25.2.1
+          Food_Delivery_25.2.1
+        ]
+      end
+
+      let(:expected_new_sprint_names) do
+        %w[
+          Food_Delivery_25.1.5
+          Food_Delivery_25.1.6
+          Food_Delivery_25.2.1
+          Food_Delivery_25.2.2
+          Food_Delivery_25.2.3
+        ]
+      end
+
+      it "does rename those sprints in sequence" do
+        expect(sprint_renamer.calculate_sprint_new_names(sprint_names)).to eq(expected_new_sprint_names)
+      end
+    end
+  end
+
+  describe "#first_sprint_to_act_on?" do
+    let(:sprint_renamer) { described_class.new(nil, "25.1.5", "25.2.1") }
+
+    def first_to_rename?(sprint_name)
+      sprint_renamer.first_sprint_to_act_on?(sprint_name)
+    end
+
+    it { expect(first_to_rename?("prefix_25.1.4")).not_to be_truthy }
+    it { expect(first_to_rename?("prefix_25.1.5")).to be_truthy }
+    it { expect(first_to_rename?("prefix_24.1.5")).not_to be_truthy }
+    it { expect(first_to_rename?("prefix_25.2.1")).not_to be_truthy }
+    it { expect(first_to_rename?("prefix_26.1.6")).not_to be_truthy }
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "jira/auto/tool/performer/sprint_end_date_updater"
+
+module Jira
+  module Auto
+    class Tool
+      class Performer
+        class SprintEndDateUpdater
+          RSpec.describe SprintEndDateUpdater do
+            let(:updater) { described_class.new(tool, "25.2.2", new_end_date_string) }
+            let(:tool) { instance_double(Tool) }
+            let(:new_end_date_string) { "2025-02-14 15:38" }
+            let(:new_end_date) { get_date(new_end_date_string) }
+
+            def get_date(date_string)
+              Time.parse(date_string)
+            end
+
+            describe "#update_sprint_end_date" do
+              let(:sprint) { instance_double(Sprint, :end_date= => nil, :save => nil, :length_in_days => 10) }
+
+              it do
+                updater.update_sprint_end_date(sprint)
+
+                expect(sprint).to have_received(:end_date=).with(new_end_date)
+                expect(sprint).to have_received(:save)
+              end
+            end
+
+            describe "#shift_sprint_to_new_start_date" do
+              let(:sprint) { instance_double(Sprint, length_in_days: 10, save: nil) }
+
+              let(:new_start_date) { get_date("2025-03-21 15:38") }
+
+              it "keeps the the sprint length unchanged" do
+                allow(sprint).to receive(:start_date=).with(new_start_date)
+                allow(sprint).to receive(:end_date=).with(get_date("2025-03-31 15:38"))
+
+                updater.shift_sprint_to_new_start_date(sprint, new_start_date)
+
+                expect(sprint).to have_received(:save)
+              end
+            end
+
+            # rubocop:disable RSpec/MultipleMemoizedHelpers
+            describe "#act_on_sprints_for_sprint_prefix" do
+              def get_sprint(name, attributes)
+                instance_double(Sprint, name: name, to_s: name, **attributes)
+              end
+
+              let(:a_sprint_that_should_not_change) { get_sprint "Food_Delivery_25.2.1", end_date: nil }
+
+              let(:a_that_should_get_a_new_end_date) do
+                get_sprint "Food_Delivery_25.2.2", end_date: get_date("2025-03-21 15:38")
+              end
+
+              let(:a_sprint_that_should_get_shifted_with_a_new_start_date) do
+                get_sprint "Food_Delivery_25.2.3", end_date: get_date("2025-03-31 15:38")
+              end
+
+              let(:sprints) do
+                [a_sprint_that_should_not_change,
+                 a_that_should_get_a_new_end_date,
+                 a_sprint_that_should_get_shifted_with_a_new_start_date]
+              end
+
+              let(:sprint_prefix) { instance_double(Sprint::Prefix, sprints: sprints) }
+
+              it "the prefix sprints as per expectations" do
+                expect(updater).to receive(:do_nothing).with(a_sprint_that_should_not_change, nil)
+                expect(updater).to receive(:update_sprint_end_date).with(a_that_should_get_a_new_end_date)
+
+                expect(updater).to receive(:shift_sprint_to_new_start_date).with(
+                  a_sprint_that_should_get_shifted_with_a_new_start_date,
+                  get_date("2025-03-21 15:38")
+                )
+
+                updater.act_on_sprints_for_sprint_prefix(sprint_prefix)
+              end
+            end
+            # rubocop:enable RSpec/MultipleMemoizedHelpers
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool/performer/sprint_renamer/keep_same_name_generator_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "jira/auto/tool/performer/sprint_renamer/keep_same_name_generator"
+
+RSpec.describe Jira::Auto::Tool::Performer::SprintRenamer::KeepSameNameGenerator do
+  let(:keep_same_name_generator) { described_class.new }
+  let(:sprint_name) { "random sprint name #{rand}" }
+
+  it { expect(keep_same_name_generator.name_for(sprint_name)).to eq(sprint_name) }
+end

data/spec/jira/auto/tool/performer/sprint_renamer/next_name_generator_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "jira/auto/tool/performer/sprint_renamer/next_name_generator"
+
+RSpec.describe Jira::Auto::Tool::Performer::SprintRenamer::NextNameGenerator do
+  def parsed_name(sprint_name)
+    Jira::Auto::Tool::Sprint::Name.parse(sprint_name)
+  end
+
+  describe "#new_name_of_sprint_next_to_first_renamed_sprint" do
+    subject(:new_name) { next_name_generator.new_name_of_sprint_next_to_first_renamed_sprint }
+
+    let(:next_name_generator) do
+      described_class.new(original_name_of_first_renamed_sprint, name_of_first_renamed_sprint)
+    end
+
+    context "when pulling sprint into previous planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_23.2.1" }
+      let(:name_of_first_renamed_sprint) { "prefix_23.1.6" }
+
+      it("returns the original sprint name") { expect(new_name).to eq(parsed_name("prefix_23.1.7")) }
+    end
+
+    context "when renaming inside planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_23.2.1" }
+      let(:name_of_first_renamed_sprint) { "prefix_23.2.4" }
+
+      it { expect(new_name).to eq(parsed_name("prefix_23.2.5")) }
+    end
+
+    context "when pushing sprint into next planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_23.1.5" }
+      let(:name_of_first_renamed_sprint) { "prefix_23.2.2" }
+
+      it("returns the original sprint parsed name") { expect(new_name).to eq(parsed_name("prefix_23.2.3")) }
+    end
+  end
+
+  describe "#pulling_sprint_into_previous_planning_interval?" do
+    let(:next_name_generator) do
+      described_class.new(original_name_of_first_renamed_sprint, name_of_first_renamed_sprint)
+    end
+
+    context "when sprint goes to the preceding planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_26.1.1" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.2.1" }
+
+      it { expect(next_name_generator).to be_pulling_sprint_into_previous_planning_interval }
+    end
+
+    context "when sprint is renamed backward inside the current preceding planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_26.1.4" }
+      let(:name_of_first_renamed_sprint) { "prefix_26.1.1" }
+
+      it { expect(next_name_generator).not_to be_pulling_sprint_into_previous_planning_interval }
+    end
+
+    context "when sprint is renamed forward inside the current planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_26.1.1" }
+      let(:name_of_first_renamed_sprint) { "prefix_26.1.4" }
+
+      it { expect(next_name_generator).not_to be_pulling_sprint_into_previous_planning_interval }
+    end
+
+    context "when sprint goes to the following planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_25.1.5" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.2.1" }
+
+      it { expect(next_name_generator).not_to be_pulling_sprint_into_previous_planning_interval }
+    end
+  end
+
+  describe "#next_name_in_planning_interval" do
+    let(:name_generator) { described_class.new(original_name_of_first_renamed_sprint, name_of_first_renamed_sprint) }
+    let(:next_names) { 4.times.collect { name_generator.next_name_in_planning_interval } }
+
+    context "when pulling to the previous planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_25.2.1" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.1.8" }
+
+      it "generates a new name consecutive to the previous one in the planning interval" do
+        expect(next_names).to eq(%w[prefix_25.1.9 prefix_25.1.10 prefix_25.1.11 prefix_25.1.12])
+      end
+    end
+
+    context "when renaming in the same planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_25.1.5" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.1.20" }
+
+      it "generates a new name consecutive to the previous one in the planning interval" do
+        expect(next_names).to eq(%w[prefix_25.1.21 prefix_25.1.22 prefix_25.1.23 prefix_25.1.24])
+      end
+    end
+
+    context "when pushing to the next planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_25.1.5" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.2.1" }
+
+      it "generates a new name consecutive to the previous one in the planning interval" do
+        expect(next_names).to eq(%w[prefix_25.2.2 prefix_25.2.3 prefix_25.2.4 prefix_25.2.5])
+      end
+    end
+  end
+
+  describe "#name_for" do
+    let(:name_generator) { described_class.new(original_name_of_first_renamed_sprint, name_of_first_renamed_sprint) }
+    let(:original_name_of_first_renamed_sprint) { "prefix_25.2.1" }
+    let(:name_of_first_renamed_sprint) { "prefix_25.1.8" }
+
+    context "when sprint name inside the planning interval" do
+      before do
+        allow(name_generator).to receive_messages(next_name_in_planning_interval: "next_name_in_planning_interval")
+      end
+
+      it { expect(name_generator.name_for("prefix_25.2.2")).to eq("next_name_in_planning_interval") }
+    end
+
+    context "when sprint name outside planning interval" do
+      let(:original_name_of_first_renamed_sprint) { "prefix_25.1.5" }
+      let(:name_of_first_renamed_sprint) { "prefix_25.2.20" }
+
+      it "generates a new name consecutive to the previous one in the planning interval" do
+        expect(name_generator.name_for("prefix_25.3.2")).to eq("prefix_25.2.21")
+      end
+    end
+  end
+end