jira-auto-tool 1.1.5 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcecb56b5f19c1cd8b4b54e50ccd801bff0e6179d0adc4c379855263dc698498
-  data.tar.gz: 021b5d028d7469d1466b324a69ace618d9973bde7c5c6f1b32df8adb1582d73a
+  metadata.gz: f848715468127f8c2d342bdd77fd68f78b2e9684c67d506c0761e6982ce325d2
+  data.tar.gz: 3c578b782fce257b587e09c0261fe60c8fcb59293b6419e097b8f9fdd52e1bd4
 SHA512:
-  metadata.gz: 80c9790171b5014a76ffcae1eae4391e7afd30fd667a48e27bd952e78e1af711e19f5c34cb030782d553de21707610d8c552a17d404f4afd755678b45b56caec
-  data.tar.gz: 7e6ea437118ada049d32f04619224de79bf6f42c3882a02e2c741c510b8a33aa9888675773ce9a9abafd5ec0adfdb32b03af46c91868b6e3ee7882aa71812d8f
+  metadata.gz: 98c0d515b13ecf5f7f145eec5729435c7378d7325dae29bd250822461badcd47081a58ace1450b51c5b68eeb59d3552ff3905ae968c3e41fdc082c7af3141f37
+  data.tar.gz: 94871345d52b7809ad2267bf12f0d62114d0d10b1032fc93856a2fd78fef6c5c6308951fa6804e073ea3a0df046d81f3c648a6caadcacaac091ec1a98babe2b9

data/README.md

@@ -7,15 +7,23 @@
 The purpose of this tool it support managing the sprints of multiple teams so it is easier to adjust to changes.
 See the [feature files](./features) for some behavior examples.
 
-## Warning
+## Table of Contents
 
-1. You should familiarize yourself with this tool in a Jira sandbox project **before applying it to your context**. 
-That can be done easily by [creating a free Atlassian account](https://www.atlassian.com/software) 
-like it has been done to document [this tool features](./features) using executable specifications.
+<!-- Generated using jekyll-toc -->
 
-1. Remember that you are **not allowed** to use confidential/sensitive information when familiarizing with this tool 
-in such a cloud sandbox. Though, if the sandbox belongs to the target context 
-(e.g., sandbox project on the client Jira instance) you can experiment with the parameters you intend to use later. 
+* TOC
+  {:toc}
+
+## Principles
+
+Following a convention over configuration approach:
+* All Scrum boards from the Jira instance are scanned to identify the ones matching the search criteria 
+(the list is [cached for a day for performance reasons](./features/cache_boards.feature) to deal with Jira 
+instances having thousands of boards);
+* For each board, only the unclosed sprints are considered;
+* Sprint manipulations only apply to those sprints whose names match the following format: `sprint_prefix_25.4.3`
+* [Creating new sprints](./features/create_sprints_using_existing_ones_as_reference.feature) 
+will use the existing ones as a reference for the prefix and the length of the sprint.
 
 ## Installation
 
@@ -41,11 +49,8 @@ in such a cloud sandbox. Though, if the sandbox belongs to the target context
    ```
 2. Adjust the file to your context. 
 
-**WARNING** - It is highly recommended that the JIRA_API_TOKEN value is set as an environment variable 
-and **NOT** in the generated file.
-
-While we strive to use convention over configuration as a principle, the following environment variables have to be set
-in order to use this tool:
+The following environment variables have to be set to use this tool. **Except** for te `JIRA_API_TOKEN` that should 
+be done via the configuration file.
 
 Some explanations:
 
@@ -67,8 +72,9 @@ Optional environment variables:
 See [sprint filtering](./features/sprint_filtering.feature).
 - `JIRA_CONTEXT_PATH` - Context path for Jira instance (if needed typically "/jira").
 - `JIRA_HTTP_DEBUG` - Enable HTTP debug logging (set to "true" or "false").
-- `JAT_RATE_LIMIT` - Rate limit for Jira API calls (e.g., "1").
-- `JAT_RATE_INTERVAL` - Interval for rate limiting in seconds (e.g., "1").
+- `JAT_RATE_LIMIT_PER_INTERVAL` - Rate limit for Jira API calls (e.g., "1") 
+See [Control Jira HTTP request rate.](./features/control_http_request_rate_limit.feature).
+- `JAT_RATE_INTERVAL_IN_SECONDS` - Interval for rate limiting in seconds (e.g., "1").
 
 ## Usage
 
@@ -79,6 +85,16 @@ See [sprint filtering](./features/sprint_filtering.feature).
 * Leverage the [specification by examples](./features) for a detailled understand of the features.
 * Note that usually the long option names have a short version equivalent to reduce typing.
 
+### Warning
+
+1. You should familiarize yourself with this tool in a Jira sandbox project **before applying it to your context**.
+   That can be done easily by [creating a free Atlassian account](https://www.atlassian.com/software)
+   like it has been done to document [this tool features](./features) using executable specifications.
+
+1. Remember that you are **not allowed** to use confidential/sensitive information when familiarizing with this tool
+   in such a cloud sandbox. Though, if the sandbox belongs to the target context
+   (e.g., sandbox project on the client Jira instance) you can experiment with the parameters you intend to use later.
+
 Below are a few examples.
 
 ### Add Sprints

data/config/examples/jira-auto-tool.env.yaml.erb

@@ -10,12 +10,15 @@ DISABLE_COVERAGE: true
 EXPECTED_START_DATE_FIELD_NAME: Expected Start
 IMPLEMENTATION_TEAM_FIELD_NAME: "Implementation Team"
 JAT_RATE_INTERVAL_IN_SECONDS:
-JAT_RATE_LIMIT_IN_SECONDS:
+JAT_RATE_LIMIT_IMPLEMENTATION:
+JAT_RATE_LIMIT_PER_INTERVAL:
 JAT_TICKETS_FOR_TEAM_SPRINT_TICKET_DISPATCHER_JQL: "project = <%= project_key %> AND <%= sprint_field_name %> IS EMPTY"
+# JIRA_BOARD_NAME: "<<<Name of one board if the project>>>"
 JIRA_BOARD_NAME: "<%= project_key %> - Delivery"
 JIRA_BOARD_NAME_REGEX: "<%= project_key %>|ART 16|unconventional board name"
 #JIRA_CONTEXT_PATH: /jira
 JIRA_CONTEXT_PATH:
+JIRA_HTTP_DEBUG:
 JIRA_PROJECT_KEY: <%= project_key %>
 JIRA_SITE_URL: http://cbroult.atlassian.net:443/
 JIRA_SPRINT_FIELD_NAME: "<%= sprint_field_name %>"

data/features/configure_environment.feature

@@ -17,7 +17,7 @@ Feature: Environment Configuration Management
       """
       ---
       <%
-        project_key = "PROJ"
+        project_key = "JATCIDEVLX"
         sprint_field_name = "Sprint"
         jira_username = "cbroult@yahoo.com"
       %>
@@ -27,11 +27,14 @@ Feature: Environment Configuration Management
       EXPECTED_START_DATE_FIELD_NAME: Expected Start
       IMPLEMENTATION_TEAM_FIELD_NAME: "Implementation Team"
       JAT_RATE_INTERVAL_IN_SECONDS:
-      JAT_RATE_LIMIT_IN_SECONDS:
+      JAT_RATE_LIMIT_IMPLEMENTATION:
+      JAT_RATE_LIMIT_PER_INTERVAL:
       JAT_TICKETS_FOR_TEAM_SPRINT_TICKET_DISPATCHER_JQL: "project = <%= project_key %> AND <%= sprint_field_name %> IS EMPTY"
-      JIRA_BOARD_NAME: "<%= project_key %> - Your board name"
+      # JIRA_BOARD_NAME: "<<<Name of one board if the project>>>"
+      JIRA_BOARD_NAME: "<%= project_key %> - Delivery"
       JIRA_BOARD_NAME_REGEX: "<%= project_key %>|ART 16|unconventional board name"
-      JIRA_CONTEXT_PATH: /jira
+      #JIRA_CONTEXT_PATH: /jira
+      JIRA_CONTEXT_PATH:
       JIRA_HTTP_DEBUG:
       JIRA_PROJECT_KEY: <%= project_key %>
       JIRA_SITE_URL: http://cbroult.atlassian.net:443/
@@ -74,7 +77,8 @@ Feature: Environment Configuration Management
       EXPECTED_START_DATE_FIELD_NAME: Expected Start
       IMPLEMENTATION_TEAM_FIELD_NAME: "Implementation Team"
       JAT_RATE_INTERVAL_IN_SECONDS:
-      JAT_RATE_LIMIT_IN_SECONDS:
+      JAT_RATE_LIMIT_IMPLEMENTATION:
+      JAT_RATE_LIMIT_PER_INTERVAL:
       JAT_TICKETS_FOR_TEAM_SPRINT_TICKET_DISPATCHER_JQL: "project = <%= project_key %> AND <%= sprint_field_name %> IS EMPTY"
       JIRA_API_TOKEN: "current API TOKEN"
       JIRA_BOARD_NAME: "Team Board"
@@ -97,7 +101,8 @@ Feature: Environment Configuration Management
 | EXPECTED_START_DATE_FIELD_NAME                    | Expected Start                     |
 | IMPLEMENTATION_TEAM_FIELD_NAME                    | Implementation Team                |
 | JAT_RATE_INTERVAL_IN_SECONDS                      |                                    |
-| JAT_RATE_LIMIT_IN_SECONDS                         |                                    |
+| JAT_RATE_LIMIT_IMPLEMENTATION                     |                                    |
+| JAT_RATE_LIMIT_PER_INTERVAL                       |                                    |
 | JAT_TICKETS_FOR_TEAM_SPRINT_TICKET_DISPATCHER_JQL | project = PROJ AND Sprint IS EMPTY |
 | JIRA_API_TOKEN                                    | current API TOKEN                  |
 | JIRA_BOARD_NAME                                   | Team Board                         |

data/features/control_http_request_rate_limit.feature

@@ -5,13 +5,25 @@ Feature: Control the HTTP request rate limit
 
   Scenario Outline: Limiting the request rate
     Given the following environment variables are set:
-      | name                         | value           |
-      | JAT_RATE_LIMIT_IN_SECONDS    | <rate_limit>    |
-      | JAT_RATE_INTERVAL_IN_SECONDS | <rate_interval> |
+      | 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:
-      | rate_limit | rate_interval | minimal_time | maximal_time |
-      | 0          | 0             | 0            | 5            |
-      | 1          | 2             | 1            | 20           |
-      | 1          | 10            | 18           | 120          |
+      | jat_rate_limit_implementation | rate_limit_per_interval | rate_interval_in_seconds | minimal_time | maximal_time |
+      |                               | 0                       | 0                        | 0            | 5            |
+      | in_process                    | 1                       | 2                        | 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/features/create_sprints_using_existing_ones_as_reference.feature

@@ -34,7 +34,7 @@ Feature: Add sprints using existing ones as reference
       | Food_Restaurant_25.3.4 | 2025-06-13 11:00:00 UTC | future |
 
   Scenario: Add several planning interval sprints
-    When I successfully run `jira-auto-tool --sprint-add=25.2.2,3  --sprint-add=25.3.1,4  --sprint-add=25.4.1,5`
+    When I successfully run `jira-auto-tool --sa=25.2.2,3  --sa=25.3.1,4  --sa=25.4.1,5`
     Then afterwards the board only has the following sprints:
       | name                   | start_date              | state  |
       | Food_Supply_25.1.3     | 2025-02-01 11:00:00 UTC | closed |

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

@@ -0,0 +1,26 @@
+# 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

@@ -0,0 +1,40 @@
+# 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,48 +1,48 @@
 # frozen_string_literal: true
 
-require "ratelimit"
-require "redis"
-
-require "jira/auto/tool"
-
 module Jira
   module Auto
     class Tool
       class RateLimitedJiraClient < JIRA::Client
-        NO_RATE_LIMIT_IN_SECONDS = 0
+        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, :rate_limit
+        attr_reader :rate_interval_in_seconds, :rate_limit_per_interval
 
-        def initialize(options, rate_interval: 1, rate_limit: 1)
+        def initialize(options, rate_interval_in_seconds: 1, rate_limit_per_interval: 1)
           super(options)
-          @rate_interval = rate_interval
-          @rate_limit = rate_limit
+          @rate_interval_in_seconds = rate_interval_in_seconds
+          @rate_limit_per_interval = rate_limit_per_interval
         end
 
         alias original_request request
-        def request(*args)
-          return original_request(*args) if rate_limit == NO_RATE_LIMIT_IN_SECONDS
-
-          rate_limiter.exec_within_threshold(rate_limiter_key, interval: rate_interval, threshold: rate_limit) do
-            response = original_request(*args)
 
-            rate_limiter.add(rate_limiter_key)
-
-            response
+        def request(*args)
+          if rate_limit_per_interval == NO_RATE_LIMIT_PER_INTERVAL
+            original_request(*args)
+          else
+            rate_limit { original_request(*args) }
           end
         end
 
-        def rate_limiter_key
-          "jira_auto_tool_api_requests"
-        end
-
-        def rate_limiter
-          self.class.rate_limiter(rate_limiter_key, rate_interval)
-        end
-
-        def self.rate_limiter(rate_limiter_key, rate_interval)
-          @rate_limiter ||= Ratelimit.new(rate_limiter_key, bucket_interval: rate_interval)
+        def rate_limit(&)
+          raise "rate_limit must be implemented by a subclass"
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module Jira
   module Auto
     class Tool
-      VERSION = "1.1.5"
+      VERSION = "1.2.0"
     end
   end
 end

data/lib/jira/auto/tool.rb

@@ -83,15 +83,17 @@ module Jira
       end
 
       def jira_client
-        RateLimitedJiraClient.new(jira_client_options,
-                                  rate_interval:
-                                    jat_rate_interval_in_seconds_when_defined_else(
-                                      RateLimitedJiraClient::NO_RATE_INTERVAL_IN_SECONDS
-                                    ).to_i,
-                                  rate_limit:
-                                    jat_rate_limit_in_seconds_when_defined_else(
-                                      RateLimitedJiraClient::NO_RATE_LIMIT_IN_SECONDS
-                                    ).to_i)
+        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)
       end
 
       def jira_client_options
@@ -105,6 +107,7 @@ module Jira
         }
       end
 
+      # TODO: fix this overly complex logic
       def jira_http_debug?
         value = if config.key?(:jira_http_debug)
                   config[:jira_http_debug]
@@ -136,12 +139,13 @@ module Jira
         jira_base_url + url
       end
 
-      %i[
+      ENVIRONMENT_BASED_VALUE_SYMBOLS = %i[
         art_sprint_regex
         expected_start_date_field_name
         implementation_team_field_name
-        jat_rate_limit_in_seconds
         jat_rate_interval_in_seconds
+        jat_rate_limit_implementation
+        jat_rate_limit_per_interval
         jat_tickets_for_team_sprint_ticket_dispatcher_jql
         jira_api_token
         jira_board_name
@@ -150,9 +154,11 @@ module Jira
         jira_http_debug
         jira_project_key
         jira_site_url
-        jira_username
         jira_sprint_field_name
-      ].each do |method_name|
+        jira_username
+      ].freeze
+
+      ENVIRONMENT_BASED_VALUE_SYMBOLS.each do |method_name|
         define_overridable_environment_based_value(method_name)
       end
 

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

@@ -0,0 +1,65 @@
+# 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

@@ -0,0 +1,56 @@
+# 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,78 +1,99 @@
 # frozen_string_literal: true
 
-require "jira/auto/tool/rate_limited_jira_client"
+require "rspec"
 
 module Jira
   module Auto
     class Tool
-      class RateLimitedJiraClient
-        RSpec.describe RateLimitedJiraClient do
-          describe "#request" do
-            let(:client) { described_class.new({}, rate_interval:, rate_limit:) }
-            let(:rate_interval) { 2 }
-            let(:rate_limit) { 1 }
-            let(:oauth_client) { instance_double(JIRA::OauthClient, request: nil, consumer: nil) }
-            let(:rate_limiter) { instance_double(Ratelimit) }
+      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(described_class).to receive_messages(rate_limiter: rate_limiter)
-
-              allow(JIRA::OauthClient).to receive_messages(new: oauth_client)
+              allow(tool).to receive_messages(jat_rate_limit_implementation_when_defined_else: nil)
+            end
 
-              allow(client).to receive_messages(original_request: :response)
+            it { expect(result).to eq(RateLimitedJiraClient::InProcessBased) }
+          end
 
-              allow(rate_limiter).to receive_messages(add: nil)
-              allow(rate_limiter).to receive(:exec_within_threshold).and_yield
+          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 "returns the response" do
-              expect(client.request(:get, "/path/to/resource")).to eq(:response)
+            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 "calls the original request method" do
-              client.request(:get, "/path/to/resource")
+            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
 
-              expect(client).to have_received(:original_request).with(:get, "/path/to/resource")
+            it do
+              expect { result }
+                .to raise_error(RuntimeError,
+                                %("unexpected_implementation": unexpected rate limiting implementation specified!"))
             end
+          end
+        end
 
-            context "when it leverages the rate limiter" do
-              it "uses :exec_within_threshold to control rate limiting" do
-                allow(rate_limiter).to receive_messages(exec_within_threshold: nil)
+        RSpec.shared_examples "a rate limited client" do
+          before do
+            allow(client).to receive_messages(original_request: :response)
+          end
 
-                4.times { client.request(:get, "/path/to/resource") }
+          it "returns the response" do
+            expect(client.request(:get, "/path/to/resource")).to eq(:response)
+          end
 
-                expect(rate_limiter)
-                  .to have_received(:exec_within_threshold)
-                  .with("jira_auto_tool_api_requests", { interval: rate_interval, threshold: rate_limit })
-                  .exactly(4).times
-              end
+          it "calls the original request method" do
+            client.request(:get, "/path/to/resource")
 
-              it "adds keeps track of the rate limiter key calls" do
-                allow(rate_limiter).to receive_messages(add: nil)
+            expect(client).to have_received(:original_request).with(:get, "/path/to/resource")
+          end
+        end
 
-                4.times { client.request(:get, "/path/to/resource") }
+        describe "#request" do
+          let(:client) { described_class.new({}, rate_interval_in_seconds:, rate_limit_per_interval:) }
 
-                expect(rate_limiter)
-                  .to have_received(:add)
-                  .with("jira_auto_tool_api_requests")
-                  .exactly(4).times
-              end
-            end
+          context "when the rate limiter is not needed" do
+            let(:rate_interval_in_seconds) { 0 }
+            let(:rate_limit_per_interval) { 0 }
 
-            context "when it does not leverage the rate limiter" do
-              let(:rate_limit) { 0 }
+            it_behaves_like "a rate limited client"
 
-              it "does not use :exec_within_threshold to control rate limiting" do
-                client.request(:get, "/path/to/resource")
+            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)
 
-                expect(rate_limiter).not_to have_received(:exec_within_threshold)
-              end
+              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 "calls the original request method" do
-                client.request(:get, "/path/to/resource")
+            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
 
-                expect(client).to have_received(:original_request).with(:get, "/path/to/resource")
-              end
+              client.request(:get, "/path/to/resource")
             end
           end
         end

data/spec/jira/auto/tool_spec.rb

@@ -16,7 +16,10 @@ module Jira
         end
 
         describe "#board_controller" do
-          before { allow(tool).to receive_messages(jira_client: instance_double(RateLimitedJiraClient)) }
+          before do
+            allow(tool)
+              .to receive_messages(jira_client: instance_double(RateLimitedJiraClient))
+          end
 
           it { expect(tool.board_controller).to be_a(BoardController) }
         end
@@ -118,7 +121,9 @@ module Jira
         end
 
         describe "#project" do
-          let(:jira_client) { instance_double(RateLimitedJiraClient, Project: project_query) }
+          let(:jira_client) do
+            instance_double(RateLimitedJiraClient, Project: project_query)
+          end
           let(:jira_project) { instance_double(JIRA::Resource::Project) }
           let(:jira_project_key) { "JIRA_PROJECT_KEY" }
           let(:project_query) { double("project_query", find: jira_project) } # rubocop:disable RSpec/VerifiedDoubles
@@ -217,21 +222,7 @@ module Jira
           end
         end
 
-        %i[
-          expected_start_date_field_name
-          implementation_team_field_name
-          jat_tickets_for_team_sprint_ticket_dispatcher_jql
-          jat_rate_limit_in_seconds
-          jat_rate_interval_in_seconds
-          jira_api_token
-          jira_board_name
-          jira_board_name_regex
-          jira_context_path
-          jira_http_debug
-          jira_project_key
-          jira_site_url jira_username
-          jira_sprint_field_name
-        ].each do |method_name|
+        described_class::ENVIRONMENT_BASED_VALUE_SYMBOLS.each do |method_name|
           describe "environment based values" do
             let(:object_with_overridable_value) { tool }
 
@@ -277,21 +268,24 @@ module Jira
             }
           end
 
+          let(:expected_jira_client) { instance_double(RateLimitedJiraClient) }
+
           before do
             allow(tool)
               .to receive_messages(jira_username: "jira_username_value", jira_site_url: "https://jira_site_url_value",
                                    jira_api_token: "jira_api_token_value",
                                    jira_context_path_when_defined_else: "/context_path_value",
                                    jira_http_debug?: false,
-                                   jat_rate_limit_in_seconds_when_defined_else: "10",
+                                   jat_rate_limit_per_interval_when_defined_else: "10",
                                    jat_rate_interval_in_seconds_when_defined_else: "60")
           end
 
           it "has a jira client" do
-            expected_jira_client = instance_double(RateLimitedJiraClient)
-
             allow(RateLimitedJiraClient)
-              .to receive(:new).with(client_options, rate_limit: 10, rate_interval: 60)
+              .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)
 
             expect(tool.jira_client).to equal(expected_jira_client)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jira-auto-tool
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.2.0
 platform: ruby
 authors:
 - Christophe Broult
@@ -163,6 +163,20 @@ 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
@@ -276,6 +290,8 @@ files:
 - 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
@@ -327,6 +343,8 @@ 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