jira-auto-tool 1.1.5 → 1.2.1

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,24 +139,29 @@ module Jira
         jira_base_url + url
       end
 
-      %i[
-        art_sprint_regex
-        expected_start_date_field_name
-        implementation_team_field_name
-        jat_rate_limit_in_seconds
-        jat_rate_interval_in_seconds
-        jat_tickets_for_team_sprint_ticket_dispatcher_jql
-        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|
-        define_overridable_environment_based_value(method_name)
+      HOLDS_A_SECRET = true
+      ENVIRONMENT_BASED_VALUE_SYMBOLS =
+        ([[:jira_api_token, HOLDS_A_SECRET]] + %i[
+          art_sprint_regex
+          expected_start_date_field_name
+          implementation_team_field_name
+          jat_rate_interval_in_seconds
+          jat_rate_limit_implementation
+          jat_rate_limit_per_interval
+          jat_tickets_for_team_sprint_ticket_dispatcher_jql
+          jira_board_name
+          jira_board_name_regex
+          jira_context_path
+          jira_http_debug
+          jira_project_key
+          jira_site_url
+          jira_sprint_field_name
+          jira_username
+        ].collect { |value_name| [value_name, !HOLDS_A_SECRET] }).freeze
+
+      ENVIRONMENT_BASED_VALUE_SYMBOLS.each do |method_name, holds_a_secret|
+        holds_a_secret ||= false
+        define_overridable_environment_based_value(method_name, holds_a_secret)
       end
 
       def board_controller

data/lib/tasks/version.rake

@@ -29,7 +29,7 @@ end
 def amend_commit_to_include_gemfile_lock_changes
   puts "Amending commit to include Gemfile.lock update..."
   system("git add .")
-  system(%(git commit --amend --no-edit))
+  system("git commit --amend --no-edit")
 end
 
 namespace :version do

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

@@ -5,6 +5,7 @@ require "rspec"
 module Jira
   module Auto
     class Tool
+      # rubocop:disable Metrics/ClassLength
       class EnvironmentLoader
         RSpec.describe EnvironmentLoader do
           let(:environment_loader) { described_class.new(tool, auto_setup: auto_setup) }
@@ -56,7 +57,7 @@ module Jira
           end
 
           describe "#tool_environment" do
-            let(:environment_keys) { %i[JIRA_HOST JIRA_USER JIRA_PASSWORD] }
+            let(:environment_keys) { %i[JIRA_SITE_URL JIRA_USERNAME JIRA_API_TOKEN] }
 
             before do
               allow(Environment).to receive(:constants).and_return(environment_keys)
@@ -64,14 +65,29 @@ module Jira
               environment_keys.each do |environment_key|
                 allow(ENV).to receive(:fetch).with(environment_key.to_s, nil).and_return("#{environment_key} value")
               end
+
+              allow(tool).to receive_messages(
+                jira_api_token_holds_a_secret?: true,
+                jira_site_url_holds_a_secret?: false,
+                jira_username_holds_a_secret?: false
+              )
             end
 
             it do
-              expect(environment_loader.tool_environment).to eq(
-                "JIRA_HOST" => "JIRA_HOST value",
-                "JIRA_USER" => "JIRA_USER value",
-                "JIRA_PASSWORD" => "JIRA_PASSWORD value"
-              )
+              expect(environment_loader.tool_environment)
+                .to eq(
+                  "JIRA_API_TOKEN" => "****",
+                  "JIRA_SITE_URL" => "JIRA_SITE_URL value",
+                  "JIRA_USERNAME" => "JIRA_USERNAME value"
+                )
+            end
+          end
+
+          describe "#environment_variable_holds_a_secret?" do
+            it "allows checking that the corresponding constant is a secret or not" do
+              allow(tool).to receive(:jira_api_token_holds_a_secret?).and_return(true)
+
+              expect(environment_loader).to be_environment_variable_holds_a_secret("JIRA_API_TOKEN")
             end
           end
 
@@ -132,10 +148,12 @@ module Jira
           end
 
           describe "#setup" do
-            it "sets up the value according to the configuration file content" do
-              allow(environment_loader).to receive_messages(file_path: "file_path")
+            before do
+              allow(environment_loader).to receive_messages(file_path: "path/to/config/file.yaml")
               allow(environment_loader).to receive_messages(config_file_content: "file_content")
+            end
 
+            it "sets up the value according to the configuration file content" do
               allow(YAML)
                 .to receive(:safe_load)
                 .with("file_content")
@@ -147,10 +165,25 @@ module Jira
 
               environment_loader.send(:setup)
             end
+
+            context "when the YAML parsing fails" do
+              it "generates an error message including the file name" do
+                allow(YAML).to receive(:safe_load)
+                  .with("file_content")
+                  .and_raise(RuntimeError, "could not find expected ':' at line 3 column 6)")
+
+                expect { environment_loader.send(:setup) }
+                  .to raise_error(RuntimeError, <<~EOEMSG
+                    path/to/config/file.yaml:188: failed to load with the following error:
+                    could not find expected ':' at line 3 column 6)
+                  EOEMSG
+                  )
+              end
+            end
           end
 
           describe "#config_file_content" do
-            let(:file_path) { "file_path" }
+            let(:file_path) { "path/to/config/file" }
             let(:file_content) do
               <<-YAML_ERB
                 ---
@@ -174,9 +207,31 @@ module Jira
             end
 
             it { expect(environment_loader.send(:config_file_content)).to eq(erb_result) }
+
+            context "when the ERB evaluation fails" do
+              let(:file_content) do
+                <<-YAML_ERB
+                  ---
+                  a_key: <%= 4*4 %>
+                  another_key: <%= 4*4 %>
+                  <%
+                  raise "An error that should be caught and reported!"#{" "}
+                  %>
+                YAML_ERB
+              end
+
+              it "generates an error message including the file name" do
+                expect { environment_loader.send(:config_file_content) }
+                  .to raise_error(RuntimeError, <<~EOEMSG)
+                    path/to/config/file:5: failed to load with the following error:
+                    An error that should be caught and reported!
+                  EOEMSG
+              end
+            end
           end
         end
       end
+      # rubocop:enable Metrics/ClassLength
     end
   end
 end

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

@@ -33,27 +33,90 @@ module Jira
               end
             end
 
+            # rubocop:disable Naming/VariableNumber, RSpec/IndexedLet
             describe "#act_on_sprints_for_sprint_prefix" do
-              def get_sprint(name, attributes)
-                instance_double(Sprint, name: name, to_s: name, **attributes)
+              def get_sprint(name, attributes = {})
+                instance_double(Sprint, name: name, to_s: name, **attributes,
+                                        parsed_name: Sprint::Name.parse(name))
               end
 
-              let(:last_sprint) { get_sprint "Food_Delivery_25.2.1", end_date: "2025-02-16 12:45", length_in_days: 10 }
+              let(:sprint_prefix) do
+                instance_double(Sprint::Prefix, name: "Food_Delivery", last_sprint: last_sprint)
+              end
+
+              context "when the sprints to create are all posterior to the last sprint from a naming perspective" do
+                let(:last_sprint) do
+                  get_sprint "Food_Delivery_25.2.1", end_date: "2025-02-16 12:45", length_in_days: 10
+                end
+
+                let(:sprint_25_3_1) { get_sprint("Food_Delivery_25.3.1") }
+                let(:sprint_25_3_2) { get_sprint("Food_Delivery_25.3.2") }
+                let(:sprint_25_3_3) { get_sprint("Food_Delivery_25.3.3") }
+                let(:sprint_25_3_4) { get_sprint("Food_Delivery_25.3.4") }
+
+                before do
+                  allow(updater).to receive(:create_sprint_for).with(last_sprint,
+                                                                     "Food_Delivery_25.3.1")
+                                                               .and_return(sprint_25_3_1)
+
+                  allow(updater).to receive(:create_sprint_for).with(sprint_25_3_1, "Food_Delivery_25.3.2")
+                                                               .and_return(sprint_25_3_2)
+
+                  allow(updater).to receive(:create_sprint_for).with(sprint_25_3_2, "Food_Delivery_25.3.3")
+                                                               .and_return(sprint_25_3_3)
+
+                  allow(updater).to receive(:create_sprint_for).with(sprint_25_3_3, "Food_Delivery_25.3.4")
+                                                               .and_return(sprint_25_3_4)
+                end
+
+                it "creates the expected number of sprints with the expected names" do
+                  expect(sprint_prefix).to receive(:<<).with(sprint_25_3_1)
+                  expect(sprint_prefix).to receive(:<<).with(sprint_25_3_2)
+                  expect(sprint_prefix).to receive(:<<).with(sprint_25_3_3)
+                  expect(sprint_prefix).to receive(:<<).with(sprint_25_3_4)
+
+                  updater.act_on_sprints_for_sprint_prefix(sprint_prefix)
+                end
+              end
+
+              context "when some sprints to create are anterior to the last sprint from a naming perspective" do
+                let(:last_sprint) do
+                  get_sprint "Food_Delivery_25.3.2", end_date: "2025-02-16 12:45", length_in_days: 10
+                end
+
+                let(:sprint_25_3_3) { get_sprint("Food_Delivery_25.3.3") }
+                let(:sprint_25_3_4) { get_sprint("Food_Delivery_25.3.4") }
+
+                before do
+                  allow(updater).to receive(:create_sprint_for).with(last_sprint, "Food_Delivery_25.3.3")
+                                                               .and_return(sprint_25_3_3)
+
+                  allow(updater).to receive(:create_sprint_for).with(sprint_25_3_3, "Food_Delivery_25.3.4")
+                                                               .and_return(sprint_25_3_4)
+                end
+
+                it "only creates the ones posterior to the last sprint" do
+                  expect(sprint_prefix).to receive(:<<).with(sprint_25_3_3)
+                  expect(sprint_prefix).to receive(:<<).with(sprint_25_3_4)
+
+                  updater.act_on_sprints_for_sprint_prefix(sprint_prefix)
+                end
+              end
 
-              let(:sprint_prefix) { instance_double(Sprint::Prefix, name: "Food_Delivery", last_sprint: last_sprint) }
+              context "when requested sprints to create are anterior to the last sprint from a naming perspective" do
+                let(:last_sprint) do
+                  get_sprint "Food_Delivery_25.4.1", end_date: "2025-02-16 12:45", length_in_days: 10
+                end
 
-              # rubocop:disable RSpec/MultipleExpectations
-              it "creates the expected number of sprints with the expected names" do
-                expect(updater).to receive(:create_sprint_for).ordered.with(last_sprint, "Food_Delivery_25.3.1")
-                expect(updater).to receive(:create_sprint_for).ordered.with(nil, "Food_Delivery_25.3.2")
-                expect(updater).to receive(:create_sprint_for).ordered.with(nil, "Food_Delivery_25.3.3")
-                expect(updater).to receive(:create_sprint_for).ordered.with(nil, "Food_Delivery_25.3.4")
-                expect(sprint_prefix).to receive(:<<).exactly(4).times
+                it "does not create any since they would be anterior to the last sprint" do
+                  expect(updater).not_to receive(:create_sprint_for)
+                  expect(sprint_prefix).not_to receive(:<<)
 
-                updater.act_on_sprints_for_sprint_prefix(sprint_prefix)
+                  updater.act_on_sprints_for_sprint_prefix(sprint_prefix)
+                end
               end
-              # rubocop:enable RSpec/MultipleExpectations
             end
+            # rubocop:enable Naming/VariableNumber, RSpec/IndexedLet
           end
         end
       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