jira-auto-tool 0.1.1

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/board_controller"
+
+module Jira
+  module Auto
+    class Tool
+      class BoardController
+        def self.filtered_boards
+          board_controller.send(:filtered_boards)
+        end
+
+        # rubocop:disable  RSpec/MultipleMemoizedHelpers
+        RSpec.describe BoardController do
+          let(:jira_client) { instance_double(JIRA::Client) }
+          let(:jira_boards) do
+            board_info.collect do |name, project_key, url|
+              jira_resource_double(JIRA::Resource::Board, name:, project_key:, url:)
+            end
+          end
+
+          let(:expected_boards) do
+            board_info.collect do |name, project_key, url, with_project_information|
+              build_board(name, project_key, url, with_project_information: with_project_information)
+            end
+          end
+
+          let(:tool) { instance_double(Tool, jira_client: jira_client) }
+          let(:board_controller) { described_class.new(tool) }
+
+          let(:board_info) do
+            [
+              ["Board 1", "ART", "https://jira.example.com/projects/ART/boards/1", true],
+              ["Board 2", "ART", "https://jira.example.com/projects/ART/boards/2", true],
+              ["Board 3", "TOOL", "https://jira.example.com/projects/TOOL/boards/3", true],
+              ["Board 4", "N/A", "https://jira.example.com/projects/TOOL/boards/4", false]
+            ]
+          end
+
+          def build_board(name, project_key, ui_url, with_project_information: true)
+            instance_double(Board, name:, project_key:, ui_url:, with_project_information?: with_project_information,
+                                   inspect: name)
+          end
+
+          describe "#list_boards" do
+            let(:expected_board_list) do
+              <<~EOBL
+                +-------------------------------------------------------------------------+
+                |                                 Boards                                  |
+                +-------------+---------+-------------------------------------------------+
+                | Project Key | Name    | Board UI URL                                    |
+                +-------------+---------+-------------------------------------------------+
+                | ART         | Board 1 | https://jira.example.com/projects/ART/boards/1  |
+                | ART         | Board 2 | https://jira.example.com/projects/ART/boards/2  |
+                | TOOL        | Board 3 | https://jira.example.com/projects/TOOL/boards/3 |
+                | N/A         | Board 4 | https://jira.example.com/projects/TOOL/boards/4 |
+                +-------------+---------+-------------------------------------------------+
+              EOBL
+            end
+
+            before do
+              allow(board_controller).to receive_messages(boards: expected_boards)
+            end
+
+            it { expect { board_controller.list_boards }.to output(expected_board_list).to_stdout }
+          end
+
+          describe "#boards" do
+            context "when the cache is invalid" do
+              let(:boards) { %i[a_board another_board] }
+
+              it "uses the API to fetch the boards and stores them in the cache" do
+                allow(board_controller)
+                  .to receive_messages(filtered_boards: boards, valid_cache?: false)
+
+                allow(board_controller).to receive_messages(cache_boards: boards)
+
+                expect(board_controller.boards).to eq(boards)
+              end
+            end
+
+            context "when the cache is valid" do
+              it "uses the API to fetch the boards and stores them in the cache" do
+                allow(board_controller)
+                  .to receive_messages(filtered_boards: %i[a_board another_board], valid_cache?: true)
+
+                allow(board_controller).to receive_messages(cached_boards: %i[a_board another_board])
+
+                expect(board_controller.boards).to eq(%i[a_board another_board])
+              end
+            end
+          end
+
+          describe "#filtered_boards" do
+            let(:project_key) { nil }
+            let(:board_name_regex) { nil }
+            let(:filtered_boards) { board_controller.send(:filtered_boards) }
+
+            before do
+              allow(board_controller).to receive_messages(unfiltered_boards: expected_boards)
+
+              allow(tool).to receive_messages(
+                jira_board_name_regex: board_name_regex,
+                jira_board_name_regex_defined?: board_name_regex,
+                jira_project_key: project_key,
+                jira_project_key_defined?: project_key
+              )
+            end
+
+            context "when using board name filtering" do
+              context "when a board name regex is specified" do
+                let(:board_name_regex) { "1|3" }
+
+                it { expect(filtered_boards).to eq(expected_boards.find_all { |b| b.name !~ /Board (2|4)/ }) }
+              end
+
+              context "when no board name regex is specified" do
+                it { expect(filtered_boards).to eq(expected_boards) }
+              end
+            end
+
+            context "when using project key filtering" do
+              context "when a project key is specified" do
+                let(:project_key) { "ART" }
+                let(:board_expected_to_be_excluded) do
+                  build_board("Board 3", "ART", "https://jira.example.com/projects/ART/boards/3")
+                end
+
+                it { expect(filtered_boards).to eq(expected_boards.find_all { |b| b.name != "Board 3" }) }
+                it { expect(filtered_boards).not_to include(board_expected_to_be_excluded) }
+              end
+
+              context "when no project key is specified" do
+                it { expect(filtered_boards).to eq(expected_boards) }
+              end
+            end
+          end
+
+          describe "#unfiltered_boards" do
+            let(:query) { jira_resource_double(all: jira_boards) }
+
+            before do
+              allow(jira_client).to receive_messages(Board: query)
+            end
+
+            it("returns boards") { expect(board_controller.send(:unfiltered_boards)).to all be_a(Board) }
+          end
+        end
+      end
+    end
+
+    # rubocop:enable  RSpec/MultipleMemoizedHelpers
+  end
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/board"
+
+module Jira
+  module Auto
+    class Tool
+      class Board
+        RSpec.describe Board do
+          let(:jira_client) { instance_double(JIRA::Client) }
+          let(:tool) { instance_double(Tool, jira_client: jira_client) }
+
+          let(:jira_board) do
+            jira_resource_double(JIRA::Resource::Board, name: "board name", url: "BOARD_URL", id: 4)
+          end
+
+          let(:board) { described_class.new(tool, jira_board) }
+
+          it { expect(board.name).to eq("board name") }
+
+          it { expect(board.url).to eq("BOARD_URL") }
+
+          it { expect(board.id).to eq(4) }
+
+          describe "#<=>" do
+            def new_board(id)
+              described_class.new(tool, instance_double(JIRA::Resource::Board, id: id))
+            end
+
+            let(:board_with_same_id) { new_board(4) }
+
+            it { expect(board <=> board_with_same_id).to eq(0) }
+            it { expect(new_board(1) <=> board).to eq(-1) }
+            it { expect(new_board(5) <=> board).to eq(1) }
+          end
+
+          describe ".find_by_id" do
+            before do
+              allow(JIRA::Resource::Board).to receive(:find).with(jira_client, 4).and_return(jira_board)
+            end
+
+            it { expect(described_class.find_by_id(tool, 4)).to eq(board) }
+
+            it "deals with non available boards" do
+              allow(JIRA::Resource::Board)
+                .to receive(:find).with(jira_client, 16)
+                                  .and_raise(JIRA::HTTPError.new(instance_double(Net::HTTPResponse, code: "404")))
+
+              expect(described_class.find_by_id(tool, 16)).to eq(Board::UnavailableBoard.new(tool, 16))
+            end
+
+            it "caches the boards" do
+              allow(JIRA::Resource::Board).to receive(:find).with(jira_client, 4).and_return(jira_board).once
+
+              board_on_1st_call = described_class.find_by_id(tool, 4)
+
+              expect(described_class.find_by_id(tool, 4)).to be(board_on_1st_call)
+            end
+          end
+
+          describe "#unavailable?" do
+            it { expect(board).not_to be_unavailable }
+            it { expect(UnavailableBoard.new(tool, 512)).to be_unavailable }
+          end
+
+          describe ".to_table_row_field_names" do
+            it { expect(described_class.to_table_row_field_names).to eq(%i[name ui_url project_key]) }
+          end
+
+          describe ".to_table_row_header" do
+            it { expect(described_class.to_table_row_header).to eq(["Name", "UI URL", "Project Key"]) }
+          end
+
+          describe "#to_table_row" do
+            before do
+              allow(board).to receive_messages(project_key: "PROJECT_KEY", ui_url: "UI_URL")
+            end
+
+            it { expect(board.to_table_row).to eq(["board name", "UI_URL", "PROJECT_KEY"]) }
+          end
+
+          describe "#sprint_compatible?" do
+            context "when a scrum board" do
+              let(:jira_board) { jira_resource_double(JIRA::Resource::Board, type: "scrum") }
+
+              it { expect(board).to be_sprint_compatible }
+            end
+
+            context "when sprints are not available" do
+              let(:jira_board) { jira_resource_double(JIRA::Resource::Board, type: "non scrum") }
+
+              it { expect(board).not_to be_sprint_compatible }
+            end
+          end
+
+          describe "#ui_url" do
+            context "when location information is not available" do
+              before do
+                allow(board).to receive_messages(with_project_information?: false)
+
+                allow(tool).to receive(:jira_url)
+                  .with("/secure/RapidBoard.jspa?rapidView=4")
+                  .and_return("https://a-jira-site.example.com/jira/secure/RapidBoard.jspa?rapidView=4")
+              end
+
+              it do
+                expect(board.ui_url)
+                  .to eq("https://a-jira-site.example.com/jira/secure/RapidBoard.jspa?rapidView=4")
+              end
+            end
+
+            context "when location information is available" do
+              # TODO: - fix the URL
+              before do
+                allow(board).to receive_messages(with_project_information?: true, project_key: "PROJECT_KEY")
+
+                allow(tool)
+                  .to receive(:jira_url)
+                  .with("/jira/software/c/projects/PROJECT_KEY/boards/4")
+                  .and_return("https://a-jira-site.example.com/jira/software/c/projects/PROJECT_KEY/boards/4")
+              end
+
+              it do
+                expect(board.ui_url)
+                  .to eq("https://a-jira-site.example.com/jira/software/c/projects/PROJECT_KEY/boards/4")
+              end
+            end
+          end
+
+          describe "#project_key" do
+            context "when location information is available" do
+              before do
+                allow(jira_board)
+                  .to receive_messages(with_project_information?: true,
+                                       location: { "projectKey" => "PROJECT_KEY" })
+              end
+
+              it { expect(board.project_key).to eq("PROJECT_KEY") }
+            end
+
+            context "when location information is not available" do
+              it { expect(board.project_key).to eq("N/A") }
+            end
+          end
+
+          describe "#with_project_information?" do
+            context "when location information is available" do
+              before do
+                allow(jira_board).to receive_messages(location: :a_location)
+              end
+
+              it { expect(board).to be_with_project_information }
+            end
+
+            context "when location information is not available" do
+              it { expect(board).not_to be_with_project_information }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "jira/auto/tool/common_options"
+
+module Jira
+  module Auto
+    class Tool
+      module CommonOptions
+        RSpec.describe CommonOptions do
+          describe ".add" do
+            let(:tool) { Tool.new }
+            let(:parser) { OptionParser.new }
+
+            before { described_class.add(tool, parser) }
+
+            context "when using --help" do
+              it do
+                expect(Kernel).to receive(:puts).with(parser)
+                expect(Kernel).to receive(:exit).with(1)
+
+                parser.parse(["--help"])
+              end
+            end
+
+            context "when using --version" do
+              it do
+                expect(Kernel).to receive(:puts).with(tool.class::VERSION)
+                expect(Kernel).to receive(:exit).with(1)
+
+                parser.parse(["--version"])
+              end
+            end
+
+            # TODO: define proper tests
+            def expect_option_use_to_be_valid(option_use_with_args)
+              expect do
+                parser.parse([option_use_with_args])
+              end.not_to raise_error
+            end
+
+            it { expect_option_use_to_be_valid(["--help"]) }
+            it { expect_option_use_to_be_valid(["-h"]) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "jira/auto/tool/config"
+
+module Jira
+  module Auto
+    class Tool
+      class Config
+        RSpec.describe Config do
+          let(:config) { described_class.new(tool) }
+          let(:tool) { instance_double(Tool) }
+
+          describe "#[]" do
+            it "returns the value of the key" do
+              allow(config).to receive_messages(value_store: { "key" => "value" })
+
+              expect(config[:key]).to eq("value")
+            end
+          end
+
+          describe "#[]=" do
+            before do
+              allow(config).to receive_messages(value_store: { "one_key" => "a_value" }, save: nil)
+            end
+
+            it "updates the value and saves the configuration" do
+              config[:key] = "value"
+
+              expect(config[:key]).to eq("value")
+              expect(config).to have_received(:save)
+            end
+          end
+
+          describe "#key?" do
+            before do
+              allow(config).to receive_messages(value_store: { "one_key" => "a_value" }, save: nil)
+            end
+
+            it { expect(config).to be_key(:one_key) }
+            it { expect(config).not_to be_key(:inexistent_key) }
+          end
+
+          describe "#load" do
+            let(:config_path) { "config-path" }
+
+            before do
+              allow(config).to receive_messages(path: config_path)
+              allow(File).to receive(:exist?).with(config_path).and_return(config_path_exists?)
+              allow(YAML).to receive(:safe_load_file).with(config_path).and_return(:config_values)
+            end
+
+            context "when the file exists" do
+              let(:config_path_exists?) { true }
+
+              it "loads the configuration from the file" do
+                config.send(:load)
+
+                expect(config).to eq(:config_values)
+              end
+            end
+
+            context "when the file does not exists" do
+              let(:config_path_exists?) { false }
+
+              it { expect(config).to eq({}) }
+            end
+          end
+
+          describe "#save" do
+            it "writes the configuration as yaml to the file" do
+              allow(config).to receive_messages(path: "config.yml", value_store: { key: "value" })
+              allow(File).to receive_messages(write: nil)
+
+              config.send(:save)
+
+              expect(File).to have_received(:write).with("config.yml", "---\n:key: value\n")
+            end
+          end
+
+          describe "#path" do
+            before do
+              allow(config).to receive_messages(dir: "path/to/config_dir")
+            end
+
+            it { expect(config.send(:path)).to eq("path/to/config_dir/jira-auto-tool.config.yml") }
+          end
+
+          describe "#dir" do
+            let(:expected_dir) { "~/.config/jira-auto-tool" }
+
+            before do
+              allow(Dir).to receive_messages(home: "~/")
+            end
+
+            it { expect(config.send(:dir)).to eq(expected_dir) }
+
+            it "creates the directory if it does not exist" do
+              expect(FileUtils).to receive(:makedirs).with(expected_dir)
+
+              config.send(:dir)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+require "jira/auto/tool/field_controller"
+
+module Jira
+  module Auto
+    class Tool
+      class FieldController
+        RSpec.describe FieldController do
+          let(:jira_client) { instance_double(JIRA::Client) }
+          let(:controller) { described_class.new(jira_client) }
+
+          def build_field(name = "a field name #{rand}", type = "unexpected_type")
+            instance_double(Field, name: name, type: type)
+          end
+
+          RSpec.shared_examples "a field fetcher" do
+            |method_under_test, expected_field_name, expected_field_type, actual_type = expected_field_type|
+
+            let(:expected_field) { build_field(expected_field_name, actual_type) }
+            let(:field_with_incorrect_type_name) { "non_#{expected_field_type}_field" }
+
+            before do
+              allow(controller)
+                .to receive(:ticket_fields)
+                .and_return([build_field, expected_field, build_field(field_with_incorrect_type_name), build_field])
+            end
+
+            context "when the field is found" do
+              let(:actual_field) { controller.send(method_under_test, expected_field_name) }
+
+              it "returns the expected field" do
+                expect(actual_field).to eq(expected_field)
+              end
+
+              it "has the expected type" do
+                expect(actual_field.type).to match_regex(expected_field_type)
+              end
+            end
+
+            it "report an unexpected field type" do
+              expect { controller.send(method_under_test, field_with_incorrect_type_name) }
+                .to raise_error(
+                  ExpectedFieldTypeError,
+                  /Field\ '#{field_with_incorrect_type_name}'\ expected\ to\ have\ type\ '#{expected_field_type}',
+                \ but\ was \ 'unexpected_type'./x
+                )
+            end
+
+            it "raises and error for a non existing field" do
+              expect { controller.send(method_under_test, "non_existing_field") }
+                .to raise_error(FieldNotFoundError, /Field 'non_existing_field' not found!/)
+            end
+          end
+
+          describe "#expected_start_date_field" do
+            it_behaves_like "a field fetcher", :expected_start_date_field, "Custom Start Date", "date"
+          end
+
+          describe "#implementation_team_field" do
+            context "when any field" do
+              it_behaves_like "a field fetcher", :implementation_team_field, "Custom Team", "option|any", "any"
+            end
+
+            context "when option field" do
+              it_behaves_like "a field fetcher", :implementation_team_field, "Custom Team", "option|any", "option"
+            end
+          end
+
+          describe "#sprint_field" do
+            it_behaves_like "a field fetcher", :sprint_field, "Custom Sprint", "array"
+          end
+
+          describe "#ticket_fields" do
+            let(:board_id) { 123 }
+            let(:jira_fields) do
+              [
+                %w[field1 date customfield_12345],
+                %w[field2 option customfield_12346]
+              ].collect { |attributes| build_jira_field(*attributes) }
+            end
+            let(:expected_fields) { jira_fields.collect { |f| Field.new(jira_client, f) } }
+
+            def build_jira_field(name, type, id)
+              jira_resource_double(JIRA::Resource::Field, name:, schema: { "type" => type }, id:)
+            end
+
+            before do
+              # rubocop:disable  RSpec/MessageChain
+              allow(jira_client).to receive_message_chain(:Field, :all).and_return(jira_fields)
+              # rubocop:enable  RSpec/MessageChain
+            end
+
+            context "when fields are successfully fetched" do
+              it "returns fields associated with the board" do
+                expect(controller.ticket_fields).to eq(expected_fields)
+              end
+            end
+
+            context "when an error occurs" do
+              before do
+                # rubocop:disable  RSpec/MessageChain
+                allow(jira_client).to receive_message_chain(:Field, :all).and_raise(StandardError,
+                                                                                    "Something went wrong")
+                # rubocop:enable  RSpec/MessageChain
+              end
+
+              it "raises an error with a descriptive message" do
+                expect do
+                  controller.ticket_fields
+                end.to raise_error(RuntimeError, /Error fetching project ticket fields: Something went wrong/)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool/field_option"
+
+module Jira
+  module Auto
+    class Tool
+      class FieldOption
+        RSpec.describe FieldOption do
+          let(:jira_client) { instance_double(JIRA::Client) }
+          let(:field_option) { described_class.new(jira_client, 123, "Test Option") }
+
+          describe "#initialize" do
+            it "assigns the id correctly" do
+              expect(field_option.id).to eq(123)
+            end
+
+            it "assigns the value correctly" do
+              expect(field_option.value).to eq("Test Option")
+            end
+          end
+
+          describe "#to_s" do
+            it "returns the correct string representation" do
+              expect(field_option.to_s).to eq("FieldOption(id: 123, value: 'Test Option')")
+            end
+          end
+
+          describe "#<=>" do
+            let(:higher_field_option) { described_class.new(jira_client, 124, "Another Option") }
+            let(:lower_field_option) { described_class.new(jira_client, 122, "Previous Option") }
+            let(:equal_field_option) { described_class.new(jira_client, 123, "Test Option") }
+
+            it { expect(field_option).to be < higher_field_option }
+            it { expect(field_option).to be > lower_field_option }
+            it { expect(field_option).to eq(equal_field_option) }
+          end
+        end
+      end
+    end
+  end
+end