jira-auto-tool 0.1.1

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require "jira/auto/tool/ticket"
+
+module Jira
+  module Auto
+    class Tool
+      class Ticket
+        RSpec.describe Ticket do
+          let(:jira_client) { instance_double(JIRA::Client) }
+          let(:tool) { instance_double(Tool, jira_client: jira_client) }
+          let(:jira_ticket) { jira_resource_double(JIRA::Resource::Issue, client: jira_client, key: "ART-12345") }
+          let(:ticket) { described_class.new(tool, jira_ticket, nil, nil) }
+          let(:sprint_field) { instance_double(Field, id: "customfield_12345", name: "Sprint") }
+
+          describe "#key" do
+            it { expect(ticket.key).to eq("ART-12345") }
+          end
+
+          context "when accessing Jira field information" do
+            describe "#jira_sprint_field" do
+              before { allow(tool).to receive_messages(jira_sprint_field: sprint_field) }
+
+              it { expect(ticket.jira_sprint_field).to eq(sprint_field) }
+            end
+
+            describe "#expected_start_date_field" do
+              let(:expected_start_date_field) do
+                instance_double(Field, id: "customfield_80044", name: "Expected Start")
+              end
+
+              before { allow(tool).to receive_messages(expected_start_date_field: expected_start_date_field) }
+
+              it { expect(ticket.expected_start_date_field).to eq(expected_start_date_field) }
+            end
+          end
+
+          context "when accessing implementation_team information" do
+            let(:implementation_team_field) do
+              instance_double(Field, id: "customfield_80044", name: "Implementation Team")
+            end
+
+            before { allow(tool).to receive_messages(implementation_team_field: implementation_team_field) }
+
+            describe "#implementation_team_field" do
+              it { expect(ticket.implementation_team_field).to eq(implementation_team_field) }
+            end
+
+            describe "#implementation_team" do
+              before do
+                allow(jira_ticket).to receive_messages(fields: fields)
+                allow(ticket).to receive_messages(implementation_team_field: implementation_team_field)
+              end
+
+              context "when not value specified" do
+                let(:fields) { { "customfield_80044" => nil } }
+
+                it { expect(ticket.implementation_team).to be_nil }
+              end
+
+              context "when stored as value" do
+                let(:fields) { { "customfield_80044" => { "value" => "A16 Logistic" } } }
+
+                it { expect(ticket.implementation_team).to eq("A16 Logistic") }
+              end
+
+              context "when stored as name" do
+                let(:fields) { { "customfield_80044" => { "name" => "A16 Logistic" } } }
+
+                it { expect(ticket.implementation_team).to eq("A16 Logistic") }
+              end
+
+              context "when the field is not present" do
+                let(:fields) { { "another key" => "some other value" } }
+
+                it "reports missing information" do
+                  expect { ticket.implementation_team }
+                    .to raise_error(RuntimeError,
+                                    /customfield_80044: value not found in #{fields.inspect}/)
+                end
+              end
+
+              context "when value or name are not present" do
+                let(:fields) { { "customfield_80044" => field_attributes } }
+                let(:field_attributes) { { "key" => "some value", "another key" => "some other value" } }
+
+                it "reports missing information" do
+                  expect { ticket.implementation_team }
+                    .to raise_error(
+                      RuntimeError,
+                      /Implementation team value and name attributes not found in #{field_attributes.inspect}!/
+                    )
+                end
+              end
+            end
+          end
+
+          describe "#sprint=" do
+            let(:sprint) { instance_double(Sprint, name: "a sprint", id: 50_400) }
+
+            it "updates the Jira ticket" do
+              allow(tool).to receive_messages(jira_sprint_field: sprint_field)
+              allow(jira_ticket).to receive_messages(save!: nil)
+
+              ticket.sprint = sprint
+
+              expect(jira_ticket).to have_received(:save!).with({ "fields" => { "customfield_12345" => 50_400 } })
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "active_support/testing/time_helpers"
+require "jira/auto/tool/until_date"
+
+module Jira
+  module Auto
+    class Tool
+      RSpec.describe Jira::Auto::Tool::UntilDate do
+        it "accepts a date with time" do
+          expect(described_class.new("2024-12-19 13:16 UTC").time).to eq(Time.new(2024, 12, 19, 13, 16, 0, "+00:00"))
+        end
+
+        RSpec::Matchers.define :be_date_until_midnight_utc do |expected_year, expected_month, expected_day|
+          def date_until_midnight_utc(expected_year, expected_month, expected_day)
+            Time.new(expected_year, expected_month, expected_day, 23, 59, 59, "UTC").end_of_day
+          end
+
+          match do |actual_until_date|
+            @date_until_midnight_utc = date_until_midnight_utc(expected_year, expected_month, expected_day)
+
+            expect(actual_until_date.time).to eq(@date_until_midnight_utc)
+          end
+
+          failure_message { |actual_until_date| build_message(actual_until_date) }
+          failure_message_when_negated { |actual_until_date| build_message(actual_until_date, "not ") }
+
+          def build_message(actual_until_date, negation_part = "")
+            "expected #{actual_until_date.inspect} #{negation_part}to be equal to #{@date_until_midnight_utc.inspect}"
+          end
+        end
+
+        context "when no time specified it adds the time until midnight UTC" do
+          it do
+            expect(described_class.new("2025-01-01")).to be_date_until_midnight_utc(2025, 1, 1)
+          end
+        end
+
+        context "when using named dates it converts to the time until midnight UTC" do
+          include ActiveSupport::Testing::TimeHelpers
+
+          let(:third_quarter_time) { Time.new(2024, 9, 16, 12, 0, 0, "+00:00") }
+
+          before { travel_to(third_quarter_time) }
+          after { travel_back }
+
+          it do
+            expect(described_class.new("today")).to be_date_until_midnight_utc(2024, 9, 16)
+          end
+
+          it do
+            expect(described_class.new("current_quarter")).to be_date_until_midnight_utc(2024, 9, 30)
+          end
+
+          it do
+            expect(described_class.new("coming_quarter")).to be_date_until_midnight_utc(2024, 12, 31)
+          end
+        end
+
+        context "when unexpected date format" do
+          it "raises an error" do
+            expect { described_class.new("current-quarter-end") }
+              .to raise_error(UntilDate::FormatError, "date string 'current-quarter-end' is not in a supported format")
+          end
+        end
+
+        describe "#current_date_time" do
+          let(:time_now) { Time.new(2024, 9, 16, 12, 0, 0, "+00:00") }
+
+          it "uses an overridable time source" do
+            allow(Helpers::OverridableTime).to receive_messages(now: time_now)
+
+            expect(described_class.new("current_quarter").current_date_time).to eq(time_now)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/jira/auto/tool_spec.rb

@@ -0,0 +1,458 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool"
+
+module Jira
+  module Auto
+    # rubocop:disable  Metrics/ClassLength
+    class Tool
+      RSpec.describe Tool do
+        let(:tool) { described_class.new }
+
+        it "has a version number" do
+          expect(Jira::Auto::Tool::VERSION).not_to be_nil
+        end
+
+        describe "#board_controller" do
+          before { allow(tool).to receive_messages(jira_client: instance_double(RateLimitedJiraClient)) }
+
+          it { expect(tool.board_controller).to be_a(BoardController) }
+        end
+
+        describe "#board" do
+          def board_double(name)
+            double("Board", name: name) # rubocop:disable RSpec/VerifiedDoubles
+          end
+
+          let(:expected_board) { board_double("a board name") }
+
+          let(:boards) do
+            other_boards = 0.upto(10).collect { |i| board_double("board_#{i}") }
+            other_boards << expected_board
+            other_boards.shuffle
+          end
+
+          it "has a board" do
+            allow(tool).to receive_messages(board_name: "a board name")
+            allow(tool).to receive_messages(boards: boards)
+
+            expect(tool.board).to equal(expected_board)
+          end
+        end
+
+        # rubocop:disable RSpec/StubbedMock
+        describe "#create_sprint" do
+          it "creates a future sprint and transitions it to the desired state" do
+            expect(tool).to receive(:transition_sprint_state).with(:created_sprint, desired_state: "a state")
+
+            expect(tool).to receive(:create_future_sprint)
+              .with({ name: "sprint_name_24.4.2", start_date: "2024-12-16 11:00 UTC",
+                      length_in_days: 14 })
+              .and_return(:created_sprint)
+
+            tool.create_sprint({ name: "sprint_name_24.4.2", start_date: "2024-12-16 11:00 UTC", length_in_days: 14,
+                                 state: "a state" })
+          end
+
+          context "when specifying end_date" do
+            it "overrides the length_in_days" do
+              expect(tool).to receive(:transition_sprint_state).with(:created_sprint, desired_state: "a state")
+
+              expect(tool).to receive(:create_future_sprint)
+                .with({ name: "sprint_name_24.4.2", start_date: "2024-12-16 11:00 UTC",
+                        end_date: "2024-12-23 11:00 UTC" })
+                .and_return(:created_sprint)
+
+              tool.create_sprint({ name: "sprint_name_24.4.2", start_date: "2024-12-16 11:00 UTC",
+                                   end_date: "2024-12-23 11:00 UTC",
+                                   state: "a state" })
+            end
+          end
+        end
+        # rubocop:enable RSpec/StubbedMock
+
+        describe "#fetch_sprint" do
+          def build_sprint(name)
+            instance_double(Sprint, name: name)
+          end
+
+          let(:expected_sprint) { build_sprint("expected_sprint_name_24.4.1") }
+
+          let(:board_sprints) do
+            other_boards = 4.times.to_a.collect { |i| build_sprint("sprint_#{i}") }
+            other_boards << expected_sprint
+            other_boards.shuffle
+          end
+
+          let(:actual_sprint_controller) { instance_double(SprintController, sprints: board_sprints) }
+
+          it do
+            allow(tool).to receive_messages(sprint_controller: actual_sprint_controller)
+
+            expect(tool.fetch_sprint("expected_sprint_name_24.4.1")).to eq(expected_sprint)
+          end
+        end
+
+        describe "#sprint_controller" do
+          let(:board) { instance_double(Board, project_key: "board_project_key") }
+
+          before do
+            allow(tool).to receive_messages(board: board)
+          end
+
+          it { expect(tool.sprint_controller).to be_a(SprintController) }
+        end
+
+        describe "#project" do
+          let(:jira_client) { instance_double(RateLimitedJiraClient, Project: project_query) }
+          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
+
+          before do
+            allow(tool).to receive_messages(jira_project_key: jira_project_key, jira_client: jira_client)
+          end
+
+          it { expect(tool.project).to be_a(Project) }
+        end
+
+        # TODO: move that to environment_based_value_spec
+        RSpec.shared_examples "an overridable environment based value" do |method_name|
+          let(:env_var_name) { method_name.to_s.upcase }
+          let(:method_name?) { :"#{method_name}_defined?" }
+          let(:config) { Config.new(object_with_overridable_value) }
+
+          before do
+            allow(object_with_overridable_value).to receive_messages(config: config)
+            allow(config).to receive_messages(value_store: {})
+          end
+
+          context "when the environment variable is set" do
+            let(:expected_value) { "#{env_var_name} env_value" }
+
+            before do
+              allow(ENV).to receive(:fetch).with(env_var_name).and_return(expected_value)
+              allow(ENV).to receive(:key?).with(env_var_name).and_return(true)
+            end
+
+            it("method_name?") { expect(object_with_overridable_value.send(method_name?)).to be(true) }
+
+            it("method_name_when_defined_else") do
+              expect(object_with_overridable_value.send("#{method_name}_when_defined_else", "DEFAULT_VALUE"))
+                .to eq(expected_value)
+            end
+
+            it "fetches its value from the environment" do
+              expect(object_with_overridable_value.send(method_name)).to eq(expected_value)
+            end
+
+            # TODO: do the following also in case the env var is not defined
+            context "when the value is defined in the configuration" do
+              let(:expected_config_value) { "<<<<#{method_name} config value>>>>" }
+
+              before { allow(config).to receive_messages(value_store: { method_name.to_s => expected_config_value }) }
+
+              it "uses the configured value" do
+                expect(object_with_overridable_value.send("#{method_name}_when_defined_else", "DEFAULT_VALUE"))
+                  .to eq(expected_config_value)
+              end
+            end
+          end
+
+          context "when the environment variable is not set" do
+            before do
+              allow(ENV).to receive(:fetch)
+                .with(env_var_name)
+                .and_raise(KeyError.new("Missing #{env_var_name} environment variable!)"))
+
+              allow(ENV).to receive(:key?).with(env_var_name).and_return(false)
+            end
+
+            it("method_name?") { expect(object_with_overridable_value.send(method_name?)).to be(false) }
+
+            it("method_name_when_defined_else") do
+              expect(object_with_overridable_value.send("#{method_name}_when_defined_else", "DEFAULT_VALUE"))
+                .to eq("DEFAULT_VALUE")
+            end
+
+            it "raises an error if the environment variable is not found" do
+              expect { object_with_overridable_value.send(method_name) }
+                .to raise_error(KeyError, /Missing #{env_var_name} environment variable!/)
+            end
+          end
+
+          it "can be overridden explicitly and updates the config" do
+            override_value = "override value for #{method_name}"
+
+            config = instance_double(Config)
+            allow(config).to receive_messages(:[]= => nil, :key? => true, :[] => override_value)
+            allow(object_with_overridable_value).to receive_messages(config: config)
+
+            object_with_overridable_value.send("#{method_name}=", override_value)
+
+            expect(object_with_overridable_value.send(method_name)).to eq(override_value)
+            expect(config).to have_received(:[]=).with(method_name, override_value)
+          end
+
+          it "defines an Environment constant with the same name" do
+            const_name = method_name.to_s.upcase
+            fully_qualified_const_name = "#{described_class}::Environment::#{const_name}"
+
+            expect(described_class.const_defined?(fully_qualified_const_name)).to be true
+            expect(described_class.const_get(fully_qualified_const_name)).to eq(const_name)
+          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|
+          describe "environment based values" do
+            let(:object_with_overridable_value) { tool }
+
+            it_behaves_like "an overridable environment based value", method_name
+          end
+        end
+
+        context "when dealing with jira site and context path related values" do
+          let(:jira_client) do
+            JIRA::Client.new({ site: "https://jira_site_url_value", context_path: "/context_path_value" })
+          end
+
+          before do
+            allow(tool).to receive_messages(jira_client: jira_client)
+          end
+
+          describe "#jira_base_url" do
+            it { expect(tool.jira_base_url).to eq("https://jira_site_url_value/context_path_value") }
+          end
+
+          describe "#jira_request_path" do
+            it { expect(tool.jira_request_path("/some/path")).to eq("/context_path_value/some/path") }
+          end
+
+          describe "#jira_url" do
+            before { allow(tool).to receive_messages(jira_base_url: "https://jira_site_url_value/context_path_value") }
+
+            it "has a jira instance url" do
+              expect(tool.jira_url("/board/4")).to eq("https://jira_site_url_value/context_path_value/board/4")
+            end
+          end
+        end
+
+        describe "#jira_client" do
+          let(:client_options) do
+            {
+              username: "jira_username_value",
+              password: "jira_api_token_value",
+              site: "https://jira_site_url_value",
+              context_path: "/context_path_value",
+              auth_type: :basic,
+              http_debug: false
+            }
+          end
+
+          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_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)
+                               .and_return(expected_jira_client)
+
+            expect(tool.jira_client).to equal(expected_jira_client)
+          end
+        end
+
+        # TODO: overly complex - simplify
+        describe "#jira_http_debug?" do
+          let(:jira_http_debug_defined?) { true }
+          let(:config) { Config.new(tool) }
+
+          before do
+            allow(tool).to receive_messages(config: config)
+          end
+
+          context "when jira_http_debug is overridden with a specific value" do
+            it "can be overridden explicitly and updates the config" do
+              tool.jira_http_debug = true
+
+              expect(tool).to be_jira_http_debug
+            end
+
+            it "can be set to false" do
+              tool.jira_http_debug = false
+
+              expect(tool).not_to be_jira_http_debug
+            end
+          end
+
+          context "when jira_http_debug has not been overridden with a specific value" do
+            before do
+              allow(tool).to receive_messages(jira_http_debug: jira_http_debug,
+                                              jira_http_debug_defined?: jira_http_debug_defined?)
+              allow(config).to receive_messages(value_store: {})
+            end
+
+            context "when a true value is set for jira_http_debug" do
+              let(:jira_http_debug) { "true" }
+
+              it { expect(tool).to be_jira_http_debug }
+            end
+
+            context "when jira_http_debug is set to nil" do
+              let(:jira_http_debug) { nil }
+
+              it { expect(tool).not_to be_jira_http_debug }
+            end
+
+            context "when a false value is set for jira_http_debug" do
+              let(:jira_http_debug) { "false" }
+
+              it { expect(tool).not_to be_jira_http_debug }
+            end
+          end
+        end
+
+        context "when dealing with ticket fields" do
+          let(:ticket_field) { instance_double(JIRA::Resource::Field) }
+
+          describe "#project_ticket_fields" do
+            let(:project) { instance_double(Project, ticket_fields: [ticket_field]) }
+
+            before do
+              allow(tool).to receive_messages(project: project)
+            end
+
+            it { expect(tool.project_ticket_fields).not_to be_empty }
+          end
+
+          describe "#expected_start_date_field" do
+            let(:field_controller) { instance_double(FieldController, expected_start_date_field: ticket_field) }
+
+            it do
+              allow(tool).to receive_messages(field_controller: field_controller)
+
+              expect(tool.expected_start_date_field("start_date_field")).not_to be_nil
+            end
+          end
+
+          describe "#implementation_team_field" do
+            let(:field_controller) { instance_double(FieldController, implementation_team_field: ticket_field) }
+
+            it do
+              allow(tool).to receive_messages(field_controller: field_controller)
+
+              expect(tool.implementation_team_field("team_field")).not_to be_nil
+            end
+          end
+        end
+
+        context "when dealing with sprints" do
+          let(:expected_sprint_prefixes) { [instance_double(Sprint::Prefix)] }
+
+          let(:sprint_controller) do
+            instance_double(SprintController,
+                            unclosed_sprints: ["a sprint", "another sprint"],
+                            unclosed_sprint_prefixes: expected_sprint_prefixes)
+          end
+
+          before do
+            allow(tool).to receive_messages(sprint_controller: sprint_controller)
+          end
+
+          describe "#unclosed_sprints" do
+            it do
+              expect(tool.unclosed_sprints).to eq(["a sprint", "another sprint"])
+            end
+          end
+
+          describe "#unclosed_sprint_prefixes" do
+            it "returns an array of sprint prefixes" do
+              expect(tool.unclosed_sprint_prefixes).to eq(expected_sprint_prefixes)
+            end
+          end
+        end
+
+        context "when dealing with mapping team tickets to sprints" do
+          describe "#team_sprint_ticket_dispatcher" do
+            before do
+              allow(tool).to receive_messages(jira_client: nil,
+                                              unclosed_sprint_prefixes: nil,
+                                              jat_tickets_for_team_sprint_ticket_dispatcher_jql: :jql_for_tickets)
+
+              allow(tool).to receive(:tickets).with(:jql_for_tickets)
+                                              .and_return([instance_double(JIRA::Resource::Issue)])
+            end
+
+            it { expect(tool.team_sprint_ticket_dispatcher).to be_a(TeamSprintTicketDispatcher) }
+          end
+
+          describe "#tickets" do
+            let(:query) { jira_resource_double("query") }
+            let(:jira_client) { instance_double(RateLimitedJiraClient, Issue: query) }
+
+            before do
+              allow(tool).to receive_messages(jira_client: jira_client)
+
+              allow(tool)
+                .to receive_messages(project: jira_resource_double(JIRA::Resource::Project, key: "project_key"))
+
+              allow(query).to receive(:jql).with(expected_jql).and_return([instance_double(JIRA::Resource::Issue)])
+            end
+
+            context "without arguments" do
+              let(:expected_jql) { "project = project_key" }
+
+              it { expect(tool.tickets).to all be_a(Ticket) }
+            end
+
+            context "with a jql" do
+              let(:expected_jql) { "a jql" }
+
+              it { expect(tool.tickets(expected_jql)).to all be_a(Ticket) }
+            end
+          end
+
+          describe "#teams" do
+            let(:team_field_options) do
+              ["a team", "another team", "a third team"].collect do |team_name|
+                instance_double(FieldOption, value: team_name)
+              end
+            end
+
+            let(:team_field) { instance_double(Field, values: team_field_options) }
+
+            it do
+              allow(tool).to receive_messages(implementation_team_field: team_field)
+
+              expect(tool.teams).to eq(["a team", "another team", "a third team"])
+            end
+          end
+        end
+      end
+    end
+
+    # rubocop:enable  Metrics/ClassLength
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "simplecov"
+
+DISABLE_COVERAGE = ENV["DISABLE_COVERAGE"] == "true"
+
+SimpleCov.start do
+  unless DISABLE_COVERAGE
+    minimum_coverage 90
+    minimum_coverage_by_file 80
+  end
+end
+
+require "jira/auto/tool"
+
+RSpec.configure do |config|
+  Encoding.default_external = Encoding::UTF_8
+  Encoding.default_internal = Encoding::UTF_8
+
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+    expectations.max_formatted_output_length = nil
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.include(Module.new do
+    def jira_resource_double(*args)
+      # rubocop:disable RSpec/VerifiedDoubles
+      double(*args)
+      # rubocop:enable RSpec/VerifiedDoubles
+    end
+  end)
+end