jira-auto-tool 1.3.7 → 1.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32efe9c3614f3e24c2287c59ba8bedf2bbded1b2bb2fa8cfdb8c9da3f4fc2def
-  data.tar.gz: 29a9e99effd2724cefc290d4e99e0b957d0fa243eeab0647f730ce5559bd3877
+  metadata.gz: 65ed9f4b2be361932c1b31bb18969304c31057d1db27f29b47a5c41f0f628402
+  data.tar.gz: e592e726bdabb7528e23440fefb04bfe9c556f355193bf4c82187571d75a7c07
 SHA512:
-  metadata.gz: b73cfe4d770d8633ddb5e5dd80c60e69fc38a61dcb48284852ba1c851d8811a63268c1e66e43c8df8a95b26d84250bac75dda300d57e784ad17951a4943227ba
-  data.tar.gz: '08db225b4adac6a7ad274cff647ab2f40c5ca5ac0f1e1f6383263db44cc8458efb9e3d802a39d82f185aa8178ff44b344b09149eedbd3e737e43ee4496c08977'
+  metadata.gz: 5aaa9c4165021446076dc4ff58a393eb6ce64c989487c3160bc312e32fb08e1901550689005cb01243d67578a3269254b3ca415514e8784626b04710473f24c2
+  data.tar.gz: b8e89f123ab16ab097b9fef0398728b4c4b4395bc4dd8f7d184e0f710cfe0b9e5aafd33f79f9ea3f7b341d07e46e3abf7b40f8481cd5c4ecb1c517904915d4c4

data/.jscpd.json

@@ -0,0 +1,7 @@
+{
+  "minTokens": 50,
+  "minLines": 5,
+  "threshold": 6,
+  "reporters": ["console"],
+  "ignore": ["**/*.gemspec", "tmp/**", "pkg/**", "coverage/**"]
+}

data/CLAUDE.md

@@ -0,0 +1,51 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+```bash
+bundle install                          # install dependencies
+bundle exec rake verify                 # run all checks (rubocop + spec + cucumber)
+bundle exec rspec                       # run all unit tests
+bundle exec rspec spec/path/to/file_spec.rb  # run a single spec file
+bundle exec cucumber                    # run all integration tests
+bundle exec cucumber features/foo.feature   # run a single feature
+bundle exec guard                       # continuous testing while developing
+bundle exec rake rubocop                # lint (with autocorrect)
+bundle exec rake version:bump[patch]    # bump version (major|minor|patch)
+bundle exec rake release                # release to rubygems.org
+```
+
+Cucumber profiles: `default` (pretty output), `guard` (rerun on failure), `rake` (progress, skips `@wip`). Tags `@in-specification` are excluded from all runs; `@wip` only from `rake`.
+
+## Architecture
+
+`Jira::Auto::Tool` (`lib/jira/auto/tool.rb`) is the central orchestrator. All configuration flows through it: environment variables are read via `EnvironmentBasedValue` and optionally overridden by a YAML config at `~/.config/jira-auto-tool/jira-auto-tool.config.yml`.
+
+### Key layers
+
+**CLI → Performer → Tool → RequestBuilder → Jira API**
+
+- **CLI** (`bin/jira-auto-tool`): OptionParser-based. Options are registered in `*/options.rb` files under each controller/performer namespace.
+- **Controllers** (`BoardController`, `SprintController`, `FieldController`): Orchestrate reads and present tabular output via `terminal-table`.
+- **Performers** (`lib/jira/auto/tool/performer/`): Encapsulate multi-sprint write operations: `SprintRenamer`, `QuarterlySprintRenamer`, `SprintEndDateUpdater`, `SprintTimeInDatesAligner`, `PlanningIncrementSprintCreator`.
+- **RequestBuilder** (`lib/jira/auto/tool/request_builder/`): Abstract base for Jira REST calls. Concrete subclasses implement `http_verb`, `request_path`, `request_payload`, `expected_response`, and message prefix methods.
+- **RateLimitedJiraClient**: Subclasses `JIRA::Client`. Two implementations: `InProcessBased` (default) and `RedisBased`. Selected via the `JAT_RATE_LIMIT_IMPLEMENTATION` env var.
+
+### Sprint naming convention
+
+Sprints must match `{prefix}_{YY}.{quarter}.{index}` (e.g., `Food_Delivery_25.3.1`). The regex lives in `Sprint::Name::SPRINT_NAME_REGEX`. Sprints that don't match are ignored with a warning.
+
+### Board caching
+
+`Board::Cache` persists board lists for one day to avoid hammering large Jira instances. Clear it with `Board::Cache.new(tool).clear`.
+
+### Environment-based configuration
+
+`EnvironmentBasedValue` dynamically generates reader, predicate (`_defined?`), writer, and `_when_defined_else` methods for every env var listed in `Tool::ENVIRONMENT_BASED_VALUE_SYMBOLS`. Config file values take precedence over env vars.
+
+### Testing approach
+
+- **Unit tests** (`spec/`): RSpec with `verify_partial_doubles`, `expect` syntax only. Coverage enforced at ≥90% overall / ≥80% per file via SimpleCov. Use `jira_resource_double` (defined in `spec_helper.rb`) instead of `double` for JIRA resource objects.
+- **Integration tests** (`features/`): Cucumber + Aruba, connecting to a real Jira sandbox. Each scenario resets state by deleting all sprints and tickets from the board and clearing the board cache in `Before` hooks.

data/Rakefile

@@ -19,7 +19,12 @@ Cucumber::Rake::Task.new do |t|
   t.profile = "rake"
 end
 
+desc "Detect copy-paste duplication"
+task :jscpd do
+  sh "jscpd lib/ spec/"
+end
+
 task default: :verify
 
 desc "Run all checks"
-task verify: %i[rubocop spec cucumber]
+task verify: %i[rubocop spec cucumber jscpd]

data/TODO.,md

@@ -0,0 +1,3 @@
+# Packwerk
+
+Please look into implementing Packwerk so we enforce better modularity if that makes sense here.

data/features/step_definitions/execution_context_steps.rb

@@ -13,17 +13,6 @@ Given(/^the following environment variables are set:$/) do |table|
   end
 end
 
-BUFFER_TIME_IN_SECONDS = 10
-Then(/^successfully running `(.*)` takes between (.*) and (.*) seconds$/) do |command_line, minimal_time, maximal_time|
-  start_time = Time.now
-
-  run_command_and_stop(command_line, fail_on_error: true, timeout: maximal_time.to_i + BUFFER_TIME_IN_SECONDS)
-
-  end_time = Time.now
-
-  expect(end_time - start_time).to be_between(minimal_time.to_i, maximal_time.to_i)
-end
-
 Given(/^I wait for over a day$/) do
   in_over_a_day = (Time.now + 1.day + 2.minute).to_s
 

data/features/step_definitions/jira_ticket_steps.rb

@@ -16,10 +16,12 @@ And(/^tickets on the board have a team field named "([^"]*)" with exactly those
   expect(@team_field.values.collect(&:value)).to eq(expected_field_values)
 end
 
+TICKET_INDEX_WAIT_SECONDS = 30
+
 Given(/^the following tickets exist:$/) do |ticket_table|
   # Summary | Description | Implementation Team | Expected Start |
   # table is a table.hashes.keys # => [:summary, :team, :expected_start]
-  ticket_table.hashes.each do |ticket_info|
+  created_keys = ticket_table.hashes.map do |ticket_info|
     log.debug { ticket_info.inspect }
 
     jira_ticket = @jira_auto_tool.jira_client.Issue.build
@@ -35,6 +37,20 @@ Given(/^the following tickets exist:$/) do |ticket_table|
                       } })
 
     log.debug { "created jira ticket: #{jira_ticket.key}" }
+    jira_ticket.key
+  end
+
+  # Jira search index is eventually consistent — poll until all created tickets are searchable
+  jql = ENV.fetch("JAT_TICKETS_FOR_TEAM_SPRINT_TICKET_DISPATCHER_JQL",
+                  "project = #{@jira_auto_tool.board.project_key}")
+  deadline = Time.now + TICKET_INDEX_WAIT_SECONDS
+  loop do
+    found_keys = @jira_auto_tool.jira_client.Issue.jql(jql, fields: ["summary"]).map(&:key)
+    break if (created_keys - found_keys).empty?
+    break if Time.now >= deadline
+
+    log.debug { "Waiting for Jira search index: #{(created_keys - found_keys).join(", ")} not yet searchable" }
+    sleep 2
   end
 end
 

data/features/support/env.rb

@@ -10,15 +10,45 @@ module JiraSprintToolWorld
 
     log.debug { "Removing sprints #sprints = #{sprints.size}: #{sprints.map(&:name).join(", ")}" }
 
-    sprints.each(&:delete)
+    sprints.each { |sprint| delete_sprint(jira_auto_tool, sprint) }
   end
 
   def remove_existing_board_tickets(jira_auto_tool)
-    tickets = jira_auto_tool.jira_client.Issue.jql("project = #{jira_auto_tool.board.project_key}")
+    tickets = jira_auto_tool.jira_client.Issue.jql("project = #{jira_auto_tool.board.project_key}",
+                                                   fields: ["key"])
 
     log.debug { "Removing tickets from board #{jira_auto_tool.board.name}:  #tickets = #{tickets.size}" }
 
-    tickets.each(&:delete)
+    tickets.each { |ticket| delete_ticket(ticket) }
+  end
+
+  private
+
+  def delete_sprint(jira_auto_tool, sprint)
+    close_active_sprint(jira_auto_tool, sprint)
+    sprint.delete
+  rescue JIRA::HTTPError => e
+    raise unless e.response.code == "404"
+
+    log.warn { "Sprint #{sprint.name} not found on delete — already removed or non-deletable state" }
+  end
+
+  def delete_ticket(ticket)
+    ticket.delete
+  rescue JIRA::HTTPError => e
+    raise unless e.response.code == "404"
+
+    log.warn { "Ticket #{ticket.key} not found on delete — already removed" }
+  end
+
+  def close_active_sprint(jira_auto_tool, sprint)
+    return unless sprint.state == Jira::Auto::Tool::SprintStateController::SprintState::ACTIVE
+
+    Jira::Auto::Tool::SprintStateController
+      .new(jira_auto_tool.jira_client, sprint)
+      .transition_to(Jira::Auto::Tool::SprintStateController::SprintState::CLOSED)
+  rescue StandardError => e
+    log.warn { "Failed to close active sprint #{sprint.name} before delete: #{e.message}" }
   end
 end
 

data/lib/jira/auto/tool/sprint_state_controller.rb

@@ -47,10 +47,23 @@ module Jira
           end
         end
 
+        MAX_STATE_UPDATE_RETRIES = 3
+        STATE_UPDATE_RETRY_DELAY_SECONDS = 2
+
         def update_sprint_state(new_state)
-          RequestBuilder::SprintStateUpdater
-            .new(jira_client, sprint: sprint, new_state: new_state)
-            .run
+          retries = 0
+          begin
+            RequestBuilder::SprintStateUpdater
+              .new(jira_client, sprint: sprint, new_state: new_state)
+              .run
+          rescue JIRA::HTTPError => e
+            raise unless e.response.code == "404" && retries < MAX_STATE_UPDATE_RETRIES
+
+            retries += 1
+            log.warn { "Sprint #{sprint.name} not found on state update (attempt #{retries}), retrying..." }
+            sleep STATE_UPDATE_RETRY_DELAY_SECONDS
+            retry
+          end
         end
       end
     end

data/lib/jira/auto/tool/version.rb

@@ -3,7 +3,7 @@
 module Jira
   module Auto
     class Tool
-      VERSION = "1.3.7"
+      VERSION = "1.3.8"
     end
   end
 end

data/lib/jira/auto/tool.rb

@@ -6,12 +6,13 @@ require "active_support/core_ext/numeric/time"
 require "active_support/core_ext/date/calculations"
 require "jira-ruby"
 
+require "rate_limited_jira"
+
 require_relative "tool/config"
 require_relative "tool/board_controller"
 require_relative "tool/environment_loader"
 require_relative "tool/helpers/environment_based_value"
 require_relative "tool/project"
-require_relative "tool/rate_limited_jira_client"
 require_relative "tool/request_builder"
 require_relative "tool/setup_logging"
 require_relative "tool/sprint_controller"
@@ -83,17 +84,12 @@ module Jira
       end
 
       def jira_client
-        RateLimitedJiraClient
-          .implementation_class_for(self)
-          .new(jira_client_options,
-               rate_interval_in_seconds:
-                 jat_rate_interval_in_seconds_when_defined_else(
-                   RateLimitedJiraClient::RedisBased::NO_RATE_INTERVAL_IN_SECONDS
-                 ).to_i,
-               rate_limit_per_interval:
-                 jat_rate_limit_per_interval_when_defined_else(
-                   RateLimitedJiraClient::RedisBased::NO_RATE_LIMIT_PER_INTERVAL
-                 ).to_i)
+        RateLimitedJira::Client.build(
+          jira_client_options,
+          rate_interval_in_seconds: jat_rate_interval_in_seconds_when_defined_else(0).to_i,
+          rate_limit_per_interval: jat_rate_limit_per_interval_when_defined_else(0).to_i,
+          implementation: jat_rate_limit_implementation_when_defined_else("")
+        )
       end
 
       def jira_client_options

data/spec/jira/auto/tool_spec.rb

@@ -18,7 +18,7 @@ module Jira
         describe "#board_controller" do
           before do
             allow(tool)
-              .to receive_messages(jira_client: instance_double(RateLimitedJiraClient))
+              .to receive_messages(jira_client: instance_double(RateLimitedJira::Client))
           end
 
           it { expect(tool.board_controller).to be_a(BoardController) }
@@ -122,7 +122,7 @@ module Jira
 
         describe "#project" do
           let(:jira_client) do
-            instance_double(RateLimitedJiraClient, Project: project_query)
+            instance_double(RateLimitedJira::Client, Project: project_query)
           end
           let(:jira_project) { instance_double(JIRA::Resource::Project) }
           let(:jira_project_key) { "JIRA_PROJECT_KEY" }
@@ -275,7 +275,7 @@ module Jira
             }
           end
 
-          let(:expected_jira_client) { instance_double(RateLimitedJiraClient) }
+          let(:expected_jira_client) { instance_double(RateLimitedJira::Client) }
 
           before do
             allow(tool)
@@ -284,16 +284,16 @@ module Jira
                                    jira_context_path_when_defined_else: "/context_path_value",
                                    jira_http_debug?: false,
                                    jat_rate_limit_per_interval_when_defined_else: "10",
-                                   jat_rate_interval_in_seconds_when_defined_else: "60")
+                                   jat_rate_interval_in_seconds_when_defined_else: "60",
+                                   jat_rate_limit_implementation_when_defined_else: "")
           end
 
           it "has a jira client" do
-            allow(RateLimitedJiraClient)
-              .to receive(:implementation_class_for).with(tool).and_return(RateLimitedJiraClient::InProcessBased)
-
-            allow(RateLimitedJiraClient::InProcessBased)
-              .to receive(:new).with(client_options, rate_limit_per_interval: 10, rate_interval_in_seconds: 60)
-                               .and_return(expected_jira_client)
+            allow(RateLimitedJira::Client)
+              .to receive(:build).with(client_options, rate_limit_per_interval: 10,
+                                                       rate_interval_in_seconds: 60,
+                                                       implementation: "")
+                                 .and_return(expected_jira_client)
 
             expect(tool.jira_client).to equal(expected_jira_client)
           end
@@ -425,7 +425,7 @@ module Jira
 
           describe "#tickets" do
             let(:query) { jira_resource_double("query") }
-            let(:jira_client) { instance_double(RateLimitedJiraClient, Issue: query) }
+            let(:jira_client) { instance_double(RateLimitedJira::Client, Issue: query) }
 
             before do
               allow(tool).to receive_messages(jira_client: jira_client)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jira-auto-tool
 version: !ruby/object:Gem::Version
-  version: 1.3.7
+  version: 1.3.8
 platform: ruby
 authors:
 - Christophe Broult
@@ -108,7 +108,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ratelimit
+  name: rate-limited-jira-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -149,20 +149,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: redis
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: reline
   requirement: !ruby/object:Gem::Requirement
@@ -177,20 +163,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: ruby-limiter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: syslog
   requirement: !ruby/object:Gem::Requirement
@@ -226,15 +198,18 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".jscpd.json"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
 - CHANGELOG.md
+- CLAUDE.md
 - CODE_OF_CONDUCT.md
 - Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- TODO.,md
 - bin/jira-auto-tool
 - bin/jira-auto-tool.bat
 - config/examples/jira-auto-tool.env.yaml.erb
@@ -247,7 +222,6 @@ files:
 - features/assign_tickets_to_team_sprints.feature
 - features/cache_boards.feature
 - features/configure_environment.feature
-- features/control_http_request_rate_limit.feature
 - features/create_sprints_using_existing_ones_as_reference.feature
 - features/list_boards.feature
 - features/list_project_fields.feature
@@ -302,9 +276,6 @@ files:
 - lib/jira/auto/tool/project.rb
 - lib/jira/auto/tool/project/options.rb
 - lib/jira/auto/tool/project/ticket_fields.rb
-- lib/jira/auto/tool/rate_limited_jira_client.rb
-- lib/jira/auto/tool/rate_limited_jira_client/in_process_based.rb
-- lib/jira/auto/tool/rate_limited_jira_client/redis_based.rb
 - lib/jira/auto/tool/request_builder.rb
 - lib/jira/auto/tool/request_builder/field_context_fetcher.rb
 - lib/jira/auto/tool/request_builder/field_option_fetcher.rb
@@ -355,9 +326,6 @@ files:
 - spec/jira/auto/tool/performer/sprint_time_in_dates_aligner_spec.rb
 - spec/jira/auto/tool/project/ticket_fields_spec.rb
 - spec/jira/auto/tool/project_spec.rb
-- spec/jira/auto/tool/rate_limited_jira_client/in_process_based_spec.rb
-- spec/jira/auto/tool/rate_limited_jira_client/redis_based_spec.rb
-- spec/jira/auto/tool/rate_limited_jira_client_spec.rb
 - spec/jira/auto/tool/request_builder/field_context_fetcher_spec.rb
 - spec/jira/auto/tool/request_builder/field_option_fetcher_spec.rb
 - spec/jira/auto/tool/request_builder/get_spec.rb

data/features/control_http_request_rate_limit.feature

@@ -1,35 +0,0 @@
-Feature: Control the HTTP request rate limit
-  In order to work against a JIRA instance imposing API rate limits
-  As a user
-  I need the ability to control the HTTP request limit
-
-  Scenario Outline: Limiting the request rate
-    Given a Jira Scrum board
-    And the board only has the following sprints:
-      | name                    | length | start_date              | state  |
-      | ART-16_CRM_24.4.1       | 2-week | 2024-12-01 11:00:00 UTC | closed |
-      | ART-16_E2E-Test_24.4.2  | 4-day  | 2024-12-05 11:00:00 UTC | future |
-      | ART-32_Platform_24.4.7  | 3-week | 2024-10-07 11:00:00 UTC | future |
-    And the following environment variables are set:
-      | name                          | value                           |
-      | JAT_RATE_INTERVAL_IN_SECONDS  | <rate_interval_in_seconds>      |
-      | JAT_RATE_LIMIT_IMPLEMENTATION | <jat_rate_limit_implementation> |
-      | JAT_RATE_LIMIT_PER_INTERVAL   | <rate_limit_per_interval>       |
-    Then successfully running `jira-auto-tool --board-list --sprint-prefix` takes between <minimal_time> and <maximal_time> seconds
-
-    Examples:
-      | jat_rate_limit_implementation | rate_limit_per_interval | rate_interval_in_seconds | minimal_time | maximal_time |
-      |                               | 0                       | 0                        | 0            | 5            |
-      | in_process                    | 1                       | 1                        | 1            | 20           |
-      | redis                         | 1                       | 2                        | 1            | 20           |
-      | redis                         | 1                       | 10                       | 18           | 120          |
-
-  Scenario: Unexpected rate limiting implementation generates an error
-    Given the following environment variables are set:
-      | name                          | value                  |
-      | JAT_RATE_LIMIT_IMPLEMENTATION | UNKNOWN IMPLEMENTATION |
-    When I run `jira-auto-tool --board-list`
-    Then it should fail with:
-      """
-      RuntimeError: "UNKNOWN IMPLEMENTATION": unexpected rate limiting implementation specified!
-      """

data/lib/jira/auto/tool/rate_limited_jira_client/in_process_based.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "ruby-limiter"
-
-require_relative "../rate_limited_jira_client"
-
-module Jira
-  module Auto
-    class Tool
-      class RateLimitedJiraClient
-        class InProcessBased < RateLimitedJiraClient
-          def rate_limit(&block)
-            rate_queue.shift
-
-            block.call
-          end
-
-          def rate_queue
-            @rate_queue ||=
-              Limiter::RateQueue.new(rate_limit_per_interval, interval: rate_interval_in_seconds)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/jira/auto/tool/rate_limited_jira_client/redis_based.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../rate_limited_jira_client"
-require "ratelimit"
-require "redis"
-
-require "jira/auto/tool"
-
-module Jira
-  module Auto
-    class Tool
-      class RateLimitedJiraClient
-        class RedisBased < RateLimitedJiraClient
-          def rate_limit(&block)
-            rate_limiter.exec_within_threshold(rate_limiter_key, interval: rate_interval_in_seconds,
-                                                                 threshold: rate_limit_per_interval) do
-              response = block.call
-
-              rate_limiter.add(rate_limiter_key)
-
-              response
-            end
-          end
-
-          def rate_limiter_key
-            "jira_auto_tool_api_requests"
-          end
-
-          def rate_limiter
-            self.class.rate_limiter(rate_limiter_key, rate_interval_in_seconds)
-          end
-
-          def self.rate_limiter(rate_limiter_key, rate_interval)
-            @rate_limiter ||= Ratelimit.new(rate_limiter_key, bucket_interval: rate_interval)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/jira/auto/tool/rate_limited_jira_client.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Jira
-  module Auto
-    class Tool
-      class RateLimitedJiraClient < JIRA::Client
-        require_relative "rate_limited_jira_client/in_process_based"
-        require_relative "rate_limited_jira_client/redis_based"
-
-        def self.implementation_class_for(tool)
-          requested_implementation = tool.jat_rate_limit_implementation_when_defined_else nil
-
-          case requested_implementation
-          when "in_process", "", nil
-            InProcessBased
-          when "redis"
-            RedisBased
-          else
-            raise %(#{requested_implementation.inspect}: unexpected rate limiting implementation specified!")
-          end
-        end
-
-        NO_RATE_LIMIT_PER_INTERVAL = 0
-        NO_RATE_INTERVAL_IN_SECONDS = 0
-
-        attr_reader :rate_interval_in_seconds, :rate_limit_per_interval
-
-        def initialize(options, rate_interval_in_seconds: 1, rate_limit_per_interval: 1)
-          super(options)
-          @rate_interval_in_seconds = rate_interval_in_seconds
-          @rate_limit_per_interval = rate_limit_per_interval
-        end
-
-        alias original_request request
-
-        def request(*)
-          if rate_limit_per_interval == NO_RATE_LIMIT_PER_INTERVAL
-            original_request(*)
-          else
-            rate_limit { original_request(*) }
-          end
-        end
-
-        def rate_limit(&)
-          raise "rate_limit must be implemented by a subclass"
-        end
-      end
-    end
-  end
-end

data/spec/jira/auto/tool/rate_limited_jira_client/in_process_based_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require "jira/auto/tool/rate_limited_jira_client/in_process_based"
-
-module Jira
-  module Auto
-    class Tool
-      class RateLimitedJiraClient
-        class InProcessBased
-          RSpec.describe InProcessBased do
-            def build_client
-              described_class.new({}, rate_interval_in_seconds:, rate_limit_per_interval:)
-            end
-
-            let(:client) { build_client }
-
-            let(:rate_interval_in_seconds) { 2 }
-            let(:rate_limit_per_interval) { 1 }
-
-            describe "#rate_limit" do
-              let(:rate_queue) { instance_double(Limiter::RateQueue) }
-
-              it "properly initializes the rate queue" do
-                allow(Limiter::RateQueue)
-                  .to receive(:new).with(rate_limit_per_interval, interval: rate_interval_in_seconds)
-                  .and_return(rate_queue)
-
-                allow(rate_queue).to receive(:shift)
-
-                expect(client.rate_limit { :do_nothing }).to eq(:do_nothing)
-              end
-
-              context "when rate limiting multiple requests" do
-                let(:rate_limit_4_calls_to_original_request_code) do
-                  4.times { client.rate_limit { client.original_request(:get, "/path/to/resource") } }
-                end
-
-                before do
-                  allow(client).to receive(:original_request).with(:get, "/path/to/resource")
-                  allow(client).to receive_messages(rate_queue: rate_queue)
-                  allow(rate_queue).to receive(:shift)
-                end
-
-                it "shifts the queue and performs the request call" do
-                  rate_limit_4_calls_to_original_request_code
-
-                  expect(rate_queue).to have_received(:shift).exactly(4).times
-                  expect(client).to have_received(:original_request).exactly(4).times
-                end
-              end
-
-              describe "#rate_queue" do
-                let(:another_client) { build_client }
-
-                it "creating a second client will return another queue" do
-                  expect(another_client.rate_queue).not_to equal(client.rate_queue)
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/jira/auto/tool/rate_limited_jira_client/redis_based_spec.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require "jira/auto/tool/rate_limited_jira_client/redis_based"
-
-module Jira
-  module Auto
-    class Tool
-      class RateLimitedJiraClient
-        class RedisBased
-          RSpec.describe RedisBased do
-            describe "#rate_limit" do
-              let(:client) { described_class.new({}, rate_interval_in_seconds:, rate_limit_per_interval:) }
-
-              let(:rate_interval_in_seconds) { 2 }
-              let(:rate_limit_per_interval) { 1 }
-              let(:rate_limiter) { instance_double(Ratelimit) }
-
-              let(:rate_limit_4_calls_to_original_request_code) do
-                4.times { client.rate_limit { client.original_request(:get, "/path/to/resource") } }
-              end
-
-              before do
-                allow(described_class).to receive_messages(rate_limiter: rate_limiter)
-                allow(client).to receive(:original_request)
-              end
-
-              it "uses :exec_within_threshold to control rate limiting" do
-                allow(rate_limiter).to receive(:exec_within_threshold)
-
-                rate_limit_4_calls_to_original_request_code
-
-                expect(rate_limiter)
-                  .to have_received(:exec_within_threshold)
-                  .with("jira_auto_tool_api_requests", { interval: rate_interval_in_seconds,
-                                                         threshold: rate_limit_per_interval })
-                  .exactly(4).times
-              end
-
-              it "adds keeps track of the rate limiter key calls" do
-                allow(rate_limiter).to receive(:exec_within_threshold).and_yield
-                allow(rate_limiter).to receive(:add)
-
-                rate_limit_4_calls_to_original_request_code
-
-                expect(rate_limiter)
-                  .to have_received(:add)
-                  .with("jira_auto_tool_api_requests")
-                  .exactly(4).times
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require "rspec"
-
-module Jira
-  module Auto
-    class Tool
-      RSpec.describe RateLimitedJiraClient do
-        describe ".implementation_class_for" do
-          let(:result) { described_class.implementation_class_for(tool) }
-          let(:tool) { instance_double(Tool) }
-
-          context "when the rate limiting implementation is unspecified" do
-            before do
-              allow(tool).to receive_messages(jat_rate_limit_implementation_when_defined_else: nil)
-            end
-
-            it { expect(result).to eq(RateLimitedJiraClient::InProcessBased) }
-          end
-
-          context "when using in process based rate limiting" do
-            before do
-              allow(tool).to receive_messages(jat_rate_limit_implementation_when_defined_else: "in_process")
-            end
-
-            it { expect(result).to eq(RateLimitedJiraClient::InProcessBased) }
-          end
-
-          context "when using in Redis based rate limiting" do
-            before do
-              allow(tool).to receive_messages(jat_rate_limit_implementation_when_defined_else: "redis")
-            end
-
-            it { expect(result).to eq(RateLimitedJiraClient::RedisBased) }
-          end
-
-          context "when the request implementation is unexpected" do
-            before do
-              allow(tool)
-                .to receive_messages(jat_rate_limit_implementation_when_defined_else: "unexpected_implementation")
-            end
-
-            it do
-              expect { result }
-                .to raise_error(RuntimeError,
-                                %("unexpected_implementation": unexpected rate limiting implementation specified!"))
-            end
-          end
-        end
-
-        RSpec.shared_examples "a rate limited client" do
-          before do
-            allow(client).to receive_messages(original_request: :response)
-          end
-
-          it "returns the response" do
-            expect(client.request(:get, "/path/to/resource")).to eq(:response)
-          end
-
-          it "calls the original request method" do
-            client.request(:get, "/path/to/resource")
-
-            expect(client).to have_received(:original_request).with(:get, "/path/to/resource")
-          end
-        end
-
-        describe "#request" do
-          let(:client) { described_class.new({}, rate_interval_in_seconds:, rate_limit_per_interval:) }
-
-          context "when the rate limiter is not needed" do
-            let(:rate_interval_in_seconds) { 0 }
-            let(:rate_limit_per_interval) { 0 }
-
-            it_behaves_like "a rate limited client"
-
-            it "does not use the rate limiter" do
-              allow(client).to receive(:original_request).with(:get, "/path/to/resource")
-              expect(client).not_to receive(:rate_limit)
-
-              client.request(:get, "/path/to/resource")
-            end
-          end
-
-          context "when the rate limiter is needed" do
-            let(:rate_interval_in_seconds) { 2 }
-            let(:rate_limit_per_interval) { 1 }
-
-            it_behaves_like "a rate limited client" do
-              before { allow(client).to receive(:rate_limit).and_yield }
-            end
-
-            it "uses the rate limiter" do
-              allow(client).to receive(:original_request).with(:get, "/path/to/resource")
-              expect(client).to receive(:rate_limit).and_yield
-
-              client.request(:get, "/path/to/resource")
-            end
-          end
-        end
-      end
-    end
-  end
-end