jira-auto-tool 0.1.1

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

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+module Jira
+  module Auto
+    # rubocop:disable Metrics/ClassLength
+    class Tool
+      # rubocop:disable RSpec/NestedGroups
+      RSpec.describe Sprint do
+        let(:jira_client) { instance_double(JIRA::Client) }
+        let(:tool) { instance_double(Tool, jira_client: jira_client) }
+        let(:jira_sprint) do
+          jira_resource_double(JIRA::Resource::Sprint,
+                               id: 40_820,
+                               name: "Food_Supply_24.4.5",
+                               startDate: "2024-12-27 13:00 UTC", endDate: "2024-12-31 13:00 UTC",
+                               state: state, originBoardId: 4096,
+                               client: jira_client,
+                               attrs: {})
+        end
+
+        let(:state) { "future" }
+
+        context "when using its attributes" do
+          let(:sprint) do
+            described_class.new(tool, jira_sprint)
+          end
+
+          describe "#jira_client" do
+            it { expect(sprint.jira_client).to eq(jira_client) }
+          end
+
+          describe "#id" do
+            it { expect(sprint.id).to eq(40_820) }
+          end
+
+          describe "#name" do
+            it { expect(sprint.name).to eq("Food_Supply_24.4.5") }
+          end
+
+          describe "#length_in_days" do
+            it { expect(sprint.length_in_days).to eq(4) }
+          end
+
+          shared_examples "an optional date" do |date_method, jira_field:, expected_value:|
+            it { expect(sprint.send(date_method)).to eq(Time.parse(expected_value).utc) }
+            it { expect(sprint.send("#{date_method}?")).to be_truthy }
+
+            context "when the sprint has no date" do
+              before do
+                allow(jira_sprint).to receive(:respond_to?).with(jira_field).and_return(false)
+              end
+
+              it("handles missing date information") { expect(sprint.send(date_method)).to eq(Sprint::UNDEFINED_DATE) }
+
+              it { expect(sprint.send("#{date_method}?")).to be_falsy }
+            end
+          end
+
+          describe "#start_date" do
+            it_behaves_like "an optional date",
+                            :start_date, jira_field: :startDate, expected_value: "2024-12-27 13:00 UTC"
+          end
+
+          describe "#start_date=" do
+            it "can set the date attribute" do
+              sprint.start_date = "2025-02-08 12:45 +0100"
+
+              expect(jira_sprint.attrs["startDate"]).to eq("2025-02-08T11:45:00Z")
+            end
+          end
+
+          describe "#end_date=" do
+            it "can set the date attribute" do
+              sprint.end_date = "2025-02-08 12:45 +0100"
+
+              expect(jira_sprint.attrs["endDate"]).to eq("2025-02-08T11:45:00Z")
+            end
+          end
+
+          describe "#end_date" do
+            it_behaves_like "an optional date",
+                            :end_date, jira_field: :endDate, expected_value: "2024-12-31 13:00 UTC"
+          end
+
+          describe "#missing_dates?" do
+            def new_sprint(start_date: Sprint::UNDEFINED_DATE, end_date: Sprint::UNDEFINED_DATE)
+              allow(sprint).to receive_messages(start_date: start_date, end_date: end_date)
+
+              sprint
+            end
+
+            it { expect(new_sprint).to be_missing_dates }
+            it { expect(new_sprint(start_date: Time.now)).to be_missing_dates }
+            it { expect(new_sprint(end_date: Time.now.tomorrow)).to be_missing_dates }
+
+            it { expect(new_sprint(start_date: Time.now, end_date: Time.now + 14.days)).not_to be_missing_dates }
+          end
+
+          describe "#state" do
+            it { expect(sprint.state).to eq("future") }
+          end
+
+          describe "#closed?" do
+            context "when the sprint state is closed" do
+              let(:state) { "closed" }
+
+              it { expect(sprint).to be_closed }
+            end
+
+            context "when the sprint state is active" do
+              let(:state) { "active" }
+
+              it { expect(sprint).not_to be_closed }
+            end
+
+            context "when the sprint state is future" do
+              let(:state) { "future" }
+
+              it { expect(sprint).not_to be_closed }
+            end
+          end
+
+          describe "#origin_board_id" do
+            it { expect(sprint.origin_board_id).to eq(4096) }
+          end
+
+          describe "#board" do
+            let(:expected_board) { instance_double(Board, name: "Food_Supply_24.4.5") }
+
+            before do
+              allow(sprint).to receive(:origin_board_id).and_return(8192)
+
+              allow(Board).to receive(:find_by_id).with(tool, 8192).and_return(expected_board)
+            end
+
+            it { expect(sprint.board).to eq(expected_board) }
+          end
+
+          describe "#renamed_to" do
+            let(:jira_sprint) { jira_resource_double(JIRA::Resource::Sprint, name: "Food_Supply_24.4.5", state: state) }
+            let(:state) { "future" }
+
+            before do
+              allow(jira_sprint).to receive_messages(save!: nil)
+            end
+
+            it "saves the sprint with the new name" do
+              allow(sprint).to receive_messages(jira_sprint: jira_sprint)
+              attrs = { name: "Food_Supply_25.4.1" }
+              allow(jira_sprint).to receive_messages(attrs: attrs, save!: nil)
+              allow(attrs).to receive(:[]=).with("name", "Food_Supply_25.4.1")
+
+              sprint.rename_to("Food_Supply_25.4.1")
+
+              expect(jira_sprint).to have_received(:save!)
+            end
+
+            it "ignores renaming to the same name" do
+              sprint.rename_to("Food_Supply_24.4.5")
+
+              expect(jira_sprint).not_to have_received(:save!)
+            end
+
+            context "when the sprint is closed" do
+              let(:state) { "closed" }
+
+              it "ignores renaming a closed sprint" do
+                sprint.rename_to("Food_Supply_25.4.1")
+
+                expect(jira_sprint).not_to have_received(:save!)
+              end
+            end
+          end
+
+          describe "#save" do
+            it "saves the sprint" do
+              allow(jira_sprint).to receive_messages(save!: nil, attrs: { "name" => "Food_Supply_25.4.1" })
+
+              # allow(sprint).to receive_messages()
+
+              sprint.save
+
+              expect(jira_sprint).to have_received(:save!)
+            end
+          end
+
+          describe "#to_table_row" do
+            let(:board) do
+              instance_double(Board, to_table_row: ["Food Supply Team Board", :url_to_suppply_team_board, "FOOD"])
+            end
+
+            before do
+              allow(sprint).to receive_messages(board: board)
+            end
+
+            it do
+              expect(sprint.to_table_row)
+                .to eq([40_820, "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
+              expect(sprint.to_table_row(without_board_information: true))
+                .to eq([40_820, "Food_Supply_24.4.5", 4, "2024-12-27 13:00 UTC", "2024-12-31 13:00 UTC"])
+            end
+          end
+
+          describe ".to_table_row_field_names" do
+            it {
+              expect(described_class.to_table_row_field_names).to eq(%i[id name length_in_days start_date end_date])
+            }
+          end
+
+          describe ".to_table_row_header" do
+            before do
+              allow(Board).to receive_messages(to_table_row_header: ["Name", "UI URL", "Project Key"])
+            end
+
+            it do
+              expect(described_class.to_table_row_header)
+                .to eq(["Id", "Name", "Length In Days", "Start Date", "End Date",
+                        "Board Name", "Board UI URL", "Board Project Key"])
+            end
+
+            it "can exclude the board information" do
+              expect(described_class.to_table_row_header(without_board_information: true))
+                .to eq(["Id", "Name", "Length In Days", "Start Date", "End Date"])
+            end
+          end
+        end
+
+        describe "#<=>" do
+          def new_sprint_named(name, start_date: "2024-12-30 13:00 UTC", end_date: "2025-01-14 13:00 UTC")
+            # rubocop:disable RSpec/VerifiedDoubles
+            described_class.new(
+              tool,
+              double(JIRA::Resource::Sprint, name: name, startDate: start_date, endDate: end_date,
+                                             originBoardId: 2048, inspect: name.inspect)
+            )
+            # rubocop:enable RSpec/VerifiedDoubles
+          end
+
+          let(:abc_sprint) { new_sprint_named("abc name_24.4.9") }
+          let(:sprint_with_missing_date) do
+            new_sprint_named("name that should not be last_24.4.9",
+                             end_date: Sprint::UNDEFINED_DATE.utc.to_s)
+          end
+
+          it { expect(sprint_with_missing_date).to be < abc_sprint }
+
+          it { expect(abc_sprint).to eq new_sprint_named("abc name_24.4.9") }
+          it { expect(abc_sprint).to be < new_sprint_named("xyz name_24.4.9") }
+          it { expect(new_sprint_named("def name_24.3.9")).to be > abc_sprint }
+
+          it { expect(new_sprint_named("foo_bar_24.4.9")).to be < new_sprint_named("foo_bar_24.4.10") }
+
+          it do
+            expect(new_sprint_named("foo_bar_24.4.9", end_date: "2025-01-14 13:00 UTC"))
+              .to be < new_sprint_named("foo_bar_24.4.9", end_date: "2025-01-15 13:00 UTC")
+          end
+
+          context "when sprint name does not respect the naming convention" do
+            it { expect(abc_sprint).to be > new_sprint_named("1st sprint") }
+            it { expect(abc_sprint).to be < new_sprint_named("name not following the naming conventions") }
+          end
+        end
+
+        describe "#comparison_fields" do
+          let(:sprint) { described_class.new(tool, jira_sprint) }
+
+          before do
+            allow(Sprint::Name).to receive_messages(respects_naming_convention?: respects_naming_convention)
+          end
+
+          context "when respecting the naming convention" do
+            let(:respects_naming_convention) { true }
+
+            it { expect(sprint.send(:comparison_fields, sprint)).to eq(%i[start_date end_date parsed_name]) }
+          end
+
+          context "when not respecting the naming convention" do
+            let(:respects_naming_convention) { false }
+
+            it { expect(sprint.send(:comparison_fields, sprint)).to eq(%i[start_date end_date name]) }
+          end
+        end
+
+        describe ".date_for_save" do
+          let(:now) { Time.now }
+
+          it { expect(described_class.date_for_save(now)).to eq(now.utc.iso8601) }
+
+          it do
+            expect(described_class.date_for_save("2025-02-08 15:15:15 +0100").force_encoding("UTF-8"))
+              .to eq("2025-02-08T14:15:15Z")
+          end
+
+          it do
+            expect { described_class.date_for_save(nil) }
+              .to raise_error(ArgumentError, "nil (NilClass), date must be a Time, Date, DateTime or a String")
+          end
+        end
+      end
+      # rubocop:enable RSpec/NestedGroups
+    end
+
+    # rubocop:enable Metrics/ClassLength
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "jira/auto/tool/team"
+
+module Jira
+  module Auto
+    class Tool
+      class Team
+        RSpec.describe Team do
+          let(:team) { described_class.new(field_option) }
+          let(:field_option) { instance_double(FieldOption, id: 123, value: "Test Team") }
+
+          it { expect(team.name).to eq("Test Team") }
+          it { expect(team.id).to eq(123) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+module Jira
+  module Auto
+    class Tool
+      class TeamSprintPrefixMapper
+        RSpec.describe TeamSprintPrefixMapper do
+          let(:mapper) do
+            described_class.new(teams, unclosed_sprint_prefixes)
+          end
+
+          let(:teams) { ["A16 CRM", "A16 Logistic", "A16 Platform", "A32 64 Sys-Team"] }
+
+          let(:expected_team_sprint_prefix_mappings) do
+            {
+              "A16 CRM" => "ART-16_CRM",
+              "A16 Platform" => "ART-16_Platform",
+              "A32 64 Sys-Team" => "ART-32-64_Sys-Team"
+            }
+          end
+
+          let(:unclosed_sprint_prefixes) do
+            %w[ART-16_CRM ART-16_Platform ART-32-64_Sys-Team].collect do |name|
+              instance_double(Sprint::Prefix, name: name)
+            end
+          end
+
+          describe "#sprint_prefixes" do
+            it { expect(mapper.sprint_prefixes).to eq unclosed_sprint_prefixes }
+          end
+
+          describe "#teams" do
+            it { expect(mapper.teams).to eq teams }
+          end
+
+          describe "#team_sprint_prefix_mappings" do
+            it { expect(mapper.team_sprint_prefix_mappings).to eq(expected_team_sprint_prefix_mappings) }
+          end
+
+          describe "#fetch_for" do
+            it { expect(mapper.fetch_for("A16 CRM")).to eq "ART-16_CRM" }
+            it { expect(mapper.fetch_for("A32 64 Sys-Team")).to eq "ART-32-64_Sys-Team" }
+
+            it "returns nil if the prefix is not found" do
+              expect(mapper.fetch_for("team with no related prefix")).to be_nil
+            end
+          end
+
+          describe "#fetch_for!" do
+            it "raises an error if the prefix is not found" do
+              expect { mapper.fetch_for!("team with no related prefix") }
+                .to raise_error(NoMatchingSprintPrefixError,
+                                /#{Regexp.escape(
+                                  "No matching sprint prefix for team 'team with no related prefix' in "
+                                )}
+                                  #{Regexp.escape(expected_team_sprint_prefix_mappings.inspect)}/x)
+            end
+          end
+
+          describe "#map_prefix_name_to_team_name" do
+            it { expect(mapper.map_prefix_name_to_team_name("ART-16_CRM")).to eq "A16 CRM" }
+            it { expect(mapper.map_prefix_name_to_team_name("ART-32-64_Sys-Team")).to eq "A32 64 Sys-Team" }
+
+            it "raises an error if the prefix is not found" do
+              expect { mapper.map_prefix_name_to_team_name("team-unrelated-prefix") }.not_to raise_error
+            end
+          end
+
+          describe "#list_mappings" do
+            let(:expected_mapping_output) do
+              <<~EOMAPPING
+                +-----------------------------------------------------+
+                |                Team Sprint Mappings                 |
+                +-----------------+-----------------------------------+
+                | Team            | Sprint Prefix                     |
+                +-----------------+-----------------------------------+
+                | A16 CRM         | ART-16_CRM                        |
+                | A16 Logistic    | !!__no matching sprint prefix__!! |
+                | A16 Platform    | ART-16_Platform                   |
+                | A32 64 Sys-Team | ART-32-64_Sys-Team                |
+                +-----------------+-----------------------------------+
+              EOMAPPING
+            end
+
+            it "lists the mappings" do
+              allow(mapper).to receive_messages(team_sprint_prefix_mappings: expected_team_sprint_prefix_mappings)
+
+              expect { mapper.list_mappings }.to output(expected_mapping_output).to_stdout
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "jira/auto/tool/team_sprint_ticket_dispatcher"
+
+module Jira
+  module Auto
+    class Tool
+      # rubocop:disable  Metrics/ClassLength, RSpec/MultipleMemoizedHelpers
+      class TeamSprintTicketDispatcher
+        RSpec.describe TeamSprintTicketDispatcher do
+          let(:jira_client) { instance_double(JIRA::Client) }
+          let(:ticket_for_1st_team) { build_ticket("Ticket1", "Team1", key: "ART-10040") }
+          let(:ticket_for_2nd_team) { build_ticket("Ticket2", "Team2", key: "ART-10041") }
+          let(:another_ticket_for_1st_team) { build_ticket("Ticket3", "Team1", key: "ART-10042") }
+          let(:another_ticket_for_2nd_team) { build_ticket("Ticket4", "Team2", key: "ART-10043") }
+          let(:tickets) do
+            [ticket_for_1st_team, ticket_for_2nd_team, another_ticket_for_1st_team, another_ticket_for_2nd_team]
+          end
+          let(:first_team) { "Team1" }
+          let(:second_team) { "Team2" }
+
+          def build_ticket(summary, implementation_team, expected_start_date = "undefined")
+            instance_double(Ticket,
+                            summary: summary,
+                            implementation_team: implementation_team,
+                            expected_start_date: expected_start_date)
+          end
+
+          def build_sprint_prefix(name, sprints = [])
+            instance_double(Sprint::Prefix, name: name, sprints: sprints)
+          end
+
+          context "when dispatching tickets" do
+            let(:dispatcher) do
+              described_class.new(jira_client, tickets, sprint_prefixes)
+            end
+
+            let(:sprint_prefix_for_1st_team) { build_sprint_prefix("ART_Team1") }
+            let(:sprint_prefix_for_2nd_team) { build_sprint_prefix("ART_Team2") }
+            let(:sprint_prefixes) { [sprint_prefix_for_1st_team, sprint_prefix_for_2nd_team] }
+
+            describe "#teams" do
+              it { expect(dispatcher.teams).to eq(%w[Team1 Team2]) }
+            end
+
+            describe "#team_sprint_prefix_mapper" do
+              it { expect(dispatcher.team_sprint_prefix_mapper).to be_a(TeamSprintPrefixMapper) }
+            end
+
+            describe "#sprint_prefix_for" do
+              it { expect(dispatcher.sprint_prefix_for(first_team)).to eq("ART_Team1") }
+              it { expect(dispatcher.sprint_prefix_for(second_team)).to eq("ART_Team2") }
+              it { expect(dispatcher.sprint_prefix_for("team w/o sprints")).to be_nil }
+            end
+
+            describe "#dispatch_tickets" do
+              before do
+                # allow(team_sprint_prefix_mapper).to receive(:fetch_for).with("Team1").once.and_return("ART_Team1")
+                # allow(team_sprint_prefix_mapper).to receive(:fetch_for).with("Team2").once.and_return("ART_Team2")
+
+                allow(ticket_for_1st_team).to receive_messages(key: "ART-10040")
+                allow(another_ticket_for_1st_team).to receive_messages(key: "ART-10042")
+
+                allow(ticket_for_2nd_team).to receive_messages(key: "ART-10042")
+                allow(another_ticket_for_2nd_team).to receive_messages(key: "ART-10044")
+
+                allow(dispatcher).to receive_messages(dispatch_tickets_to_prefix_sprints: nil)
+              end
+
+              it "dispatches 1st team tickets to the expected prefix" do
+                dispatcher.dispatch_tickets
+
+                expect(dispatcher)
+                  .to have_received(:dispatch_tickets_to_prefix_sprints).with("ART_Team1",
+                                                                              [ticket_for_1st_team,
+                                                                               another_ticket_for_1st_team]).once
+              end
+
+              it "dispatches 2nd team tickets to the expected prefix" do
+                dispatcher.dispatch_tickets
+
+                expect(dispatcher)
+                  .to have_received(:dispatch_tickets_to_prefix_sprints).with("ART_Team2",
+                                                                              [ticket_for_2nd_team,
+                                                                               another_ticket_for_2nd_team]).once
+              end
+            end
+
+            describe "#dispatch_tickets_to_prefix_sprints" do
+              before do
+                allow(ticket_for_1st_team).to receive_messages(:sprint= => nil)
+                allow(another_ticket_for_1st_team).to receive_messages(:sprint= => nil)
+              end
+
+              let(:ticket_planned_after_last_available_sprint) { build_ticket("Ticket5", "Team1") }
+
+              it "updates each ticket with matched sprint" do
+                allow(dispatcher).to receive(:match_ticket_to_prefix_sprint)
+                  .with(sprint_prefix_for_1st_team, ticket_for_1st_team).and_return(:first_sprint)
+
+                allow(dispatcher).to receive(:match_ticket_to_prefix_sprint)
+                  .with(sprint_prefix_for_1st_team, another_ticket_for_1st_team).and_return(:second_sprint)
+
+                dispatcher.dispatch_tickets_to_prefix_sprints("ART_Team1",
+                                                              [ticket_for_1st_team,
+                                                               another_ticket_for_1st_team])
+
+                expect(ticket_for_1st_team).to have_received(:sprint=).with(:first_sprint)
+                expect(another_ticket_for_1st_team).to have_received(:sprint=).with(:second_sprint)
+              end
+
+              it "does not update tickets that do not match a sprint" do
+                allow(ticket_planned_after_last_available_sprint).to receive_messages(:sprint= => nil)
+
+                allow(dispatcher).to receive(:match_ticket_to_prefix_sprint)
+                  .with(sprint_prefix_for_1st_team, ticket_planned_after_last_available_sprint)
+                  .and_return(nil)
+
+                dispatcher.dispatch_tickets_to_prefix_sprints("ART_Team1",
+                                                              [ticket_planned_after_last_available_sprint])
+
+                expect(ticket_planned_after_last_available_sprint).not_to have_received(:sprint=)
+              end
+            end
+          end
+
+          context "when iterating over tickets" do
+            let(:dispatcher) { described_class.new(jira_client, tickets, nil) }
+
+            describe "#per_team_tickets" do
+              it "succeeds" do
+                expect { |block| dispatcher.per_team_tickets(&block) }
+                  .to yield_successive_args(
+                    [first_team, [ticket_for_1st_team, another_ticket_for_1st_team]],
+                    [second_team, [ticket_for_2nd_team, another_ticket_for_2nd_team]]
+                  )
+              end
+            end
+          end
+
+          context "when matching tickets to prefix sprints" do
+            let(:dispatcher) { described_class.new(jira_client, nil, nil) }
+
+            describe "#dispatch_to_prefix" do
+              RSpec::Matchers.define :be_dispatched_to_sprint do |expected_sprint|
+                match do |ticket|
+                  matched_sprint = dispatcher.match_ticket_to_prefix_sprint(sprint_prefix, ticket)
+
+                  log.debug do
+                    <<-EOMATCHINFO
+                    ticket: #{ticket.expected_start_date}
+                    matched sprint: #{matched_sprint&.name} #{matched_sprint&.start_date}" }
+                    expected sprint: #{expected_sprint&.name} #{expected_sprint&.start_date}"
+                    EOMATCHINFO
+                  end
+
+                  matched_sprint && matched_sprint.name == expected_sprint.name
+                end
+
+                failure_message do |ticket|
+                  build_message(expected_sprint, ticket,
+                                "but it did not match any sprint or matched an incorrect sprint")
+                end
+
+                failure_message_when_negated do |ticket_date|
+                  build_message(expected_sprint, ticket_date,
+                                "but it matched the expected sprint",
+                                "not ")
+                end
+
+                def build_message(expected_sprint, ticket, message, condition = "")
+                  "expected ticket with start date #{ticket.expected_start_date} #{condition}to dispatch to sprint " \
+                  "#{expected_sprint} (name = #{expected_sprint.name}, " \
+                  "start date = #{expected_sprint.start_date}), " +
+                    message
+                end
+              end
+
+              def build_sprint(name, start_date, end_date)
+                instance_double(Sprint,
+                                name: name,
+                                start_date: Time.parse(start_date),
+                                end_date: Time.parse(end_date))
+              end
+
+              def ticket_due_to_start_on(start_date)
+                build_ticket("ticket_name for #{start_date}", "Team1", start_date)
+              end
+
+              let(:sprint_prefix) do
+                build_sprint_prefix("a sprint prefix",
+                                    [active_sprint, coming_sprint, next_sprint, last_available_sprint])
+              end
+
+              let(:active_sprint) { build_sprint("sprint1", "2025-01-01", "2025-01-04") }
+              let(:coming_sprint) { build_sprint("sprint2", "2025-01-04", "2025-01-07") }
+              let(:next_sprint) { build_sprint("sprint3", "2025-01-07", "2025-01-10") }
+              let(:last_available_sprint) { build_sprint("sprint4", "2025-01-10", "2025-01-13") }
+
+              let(:overdue_ticket) { ticket_due_to_start_on("2024-12-25") }
+              let(:ticket_to_start_at_beginning_of_coming_sprint) { ticket_due_to_start_on("2025-01-04") }
+              let(:ticket_to_start_at_end_of_coming_sprint) { ticket_due_to_start_on("2025-01-07") }
+              let(:ticket_planned_after_last_available_sprint) { ticket_due_to_start_on("2025-01-14") }
+
+              it { expect(overdue_ticket).to be_dispatched_to_sprint(active_sprint) }
+
+              it { expect(ticket_to_start_at_beginning_of_coming_sprint).to be_dispatched_to_sprint(coming_sprint) }
+
+              it { expect(ticket_to_start_at_end_of_coming_sprint).not_to be_dispatched_to_sprint(coming_sprint) }
+              it { expect(ticket_to_start_at_end_of_coming_sprint).to be_dispatched_to_sprint(next_sprint) }
+
+              it do
+                expect(ticket_planned_after_last_available_sprint)
+                  .not_to be_dispatched_to_sprint(last_available_sprint)
+              end
+
+              it "does not match a ticket planned after the last sprint" do
+                expect(dispatcher.match_ticket_to_prefix_sprint(
+                         sprint_prefix, ticket_planned_after_last_available_sprint
+                       ))
+                  .to be_nil
+              end
+            end
+          end
+        end
+      end
+
+      # rubocop:enable  Metrics/ClassLength, RSpec/MultipleMemoizedHelpers
+    end
+  end
+end