jigit 1.0.0

data/lib/jigit/helpers/keychain_storage.rb

@@ -0,0 +1,19 @@
+require "keychain"
+
+module Jigit
+  class KeychainStorage
+    def initialize(keychain = nil)
+      @keychain = keychain ? keychain : Keychain.default
+    end
+
+    def save(account, password, service)
+      @keychain.generic_passwords.create(service: service, account: account, password: password)
+    rescue Keychain::DuplicateItemError => e
+      puts "Duplicated item in keychain storage: #{e.message}"
+    end
+
+    def load_item(service)
+      @keychain.generic_passwords.where(service: service).first
+    end
+  end
+end

data/lib/jigit/jira/jira_api_client.rb

@@ -0,0 +1,80 @@
+require "jira-ruby"
+require "jigit/jira/resources/jira_issue"
+require "jigit/jira/resources/jira_status"
+require "jigit/jira/resources/jira_transition"
+require "jigit/jira/jira_api_client_error"
+
+module Jigit
+  class JiraAPIClient
+    def initialize(config, jira_client = nil)
+      raise "Config must not be nil to use JiraHelper" unless config
+      @config = config
+      @jira_client = jira_client
+    end
+
+    def jira_client
+      return @jira_client if @jira_client
+      options = {
+            username: @config.user,
+            password: @config.password,
+            site: "https://#{@config.host}",
+            context_path: "",
+            auth_type: :basic
+          }
+      @jira_client ||= JIRA::Client.new(options)
+    end
+
+    def validate_api?
+      serverinfo = jira_client.ServerInfo.all
+      return !serverinfo.nil?
+    rescue SocketError => exception
+      raise Jigit::NetworkError, "Can not fetch Jira server info: #{exception.message}"
+    rescue JIRA::HTTPError => exception
+      raise Jigit::JiraAPIClientError, "Can not fetch Jira server info: #{exception.message}"
+    end
+
+    def fetch_issue_transitions(issue)
+      raise "Can not fetch a JIRA issue's transitions without issue name" unless issue.jira_ruby_issue
+      begin
+        transitions = jira_client.Transition.all(issue: issue.jira_ruby_issue)
+        return nil unless transitions
+        transitions.map do |transition|
+          Jigit::JiraTransition.new(transition)
+        end
+      rescue SocketError => exception
+        raise Jigit::NetworkError, "Can not fetch JIRA issue transitions: #{exception.message}"
+      rescue JIRA::HTTPError => exception
+        raise Jigit::JiraAPIClientError, "Can not fetch JIRA issue transitions: #{exception.response.body}"
+      end
+    end
+
+    def fetch_jira_issue(issue_name)
+      raise "Can not fetch a JIRA issue without issue name" unless issue_name
+      begin
+        issue = jira_client.Issue.jql("key = #{issue_name}").first
+        return nil unless issue
+        Jigit::JiraIssue.new(issue)
+      rescue SocketError => exception
+        raise Jigit::NetworkError, "Can not fetch a JIRA issue: #{exception.message}"
+      rescue JIRA::HTTPError => exception
+        error = case exception.response.code
+                when "400" then Jigit::JiraInvalidIssueKeyError
+                else Jigit::JiraAPIClientError
+                end
+        raise error, "Can not fetch a JIRA issue: #{exception.response.body}"
+      end
+    end
+
+    def fetch_jira_statuses
+      statuses = jira_client.Status.all
+      return nil unless statuses
+      statuses.map do |status|
+        Jigit::JiraStatus.new(status)
+      end
+    rescue SocketError => exception
+      raise Jigit::NetworkError, "Can not fetch a JIRA statuses: #{exception.message}"
+    rescue JIRA::HTTPError => exception
+      raise Jigit::JiraAPIClientError, "Can not fetch a JIRA statuses: #{exception.response.body}"
+    end
+  end
+end

data/lib/jigit/jira/jira_api_client_error.rb

@@ -0,0 +1,10 @@
+module Jigit
+  class JiraAPIClientError < StandardError
+  end
+
+  class NetworkError < StandardError
+  end
+
+  class JiraInvalidIssueKeyError < StandardError
+  end
+end

data/lib/jigit/jira/jira_config.rb

@@ -0,0 +1,16 @@
+module Jigit
+  class JiraConfig
+    attr_accessor :user
+    attr_accessor :password
+    attr_accessor :host
+
+    def initialize(user, password, host)
+      raise "User name must not be nil" unless user
+      raise "Password must not be nil" unless password
+      raise "Host must not be nil" unless host
+      self.user = user
+      self.password = password
+      self.host = host
+    end
+  end
+end

data/lib/jigit/jira/jira_transition_finder.rb

@@ -0,0 +1,16 @@
+require "jigit/jira/resources/jira_transition"
+
+module Jigit
+  class JiraTransitionFinder
+    def initialize(transitions)
+      @transitions = transitions
+    end
+
+    def find_transition_to(status_name)
+      return nil unless @transitions
+      @transitions.select do |transition|
+        transition.to_status.name == status_name
+      end.first
+    end
+  end
+end

data/lib/jigit/jira/resources/jira_issue.rb

@@ -0,0 +1,34 @@
+require "jigit/jira/resources/jira_status"
+require "jigit/jira/resources/jira_transition"
+
+module Jigit
+  class JiraIssue
+    attr_reader :jira_ruby_issue
+
+    def initialize(jira_ruby_issue)
+      raise "Can not initialize JiraIssue without jira-ruby issue" unless jira_ruby_issue
+      @jira_ruby_issue = jira_ruby_issue
+    end
+
+    def key
+      @jira_ruby_issue.key
+    end
+
+    def status
+      Jigit::JiraStatus.new(@jira_ruby_issue.status)
+    end
+
+    def assignee_name
+      @jira_ruby_issue.assignee.name
+    end
+
+    def type
+    end
+
+    def make_transition(transition_id)
+      raise "status_id must not be nil" unless transition_id
+      transition = @jira_ruby_issue.transitions.build
+      transition.save!("transition" => { "id" => transition_id })
+    end
+  end
+end

data/lib/jigit/jira/resources/jira_status.rb

@@ -0,0 +1,18 @@
+module Jigit
+  class JiraStatus
+    attr_reader :jira_ruby_status
+
+    def initialize(jira_ruby_status)
+      raise "Can not initialize JiraStatus without jira-ruby status" unless jira_ruby_status
+      @jira_ruby_status = jira_ruby_status
+    end
+
+    def id
+      @jira_ruby_status.id
+    end
+
+    def name
+      @jira_ruby_status.name
+    end
+  end
+end

data/lib/jigit/jira/resources/jira_transition.rb

@@ -0,0 +1,18 @@
+module Jigit
+  class JiraTransition
+    attr_reader :jira_ruby_transition
+
+    def initialize(jira_ruby_transition)
+      raise "Can not initialize transition without jira-ruby transition" unless jira_ruby_transition
+      @jira_ruby_transition = jira_ruby_transition
+    end
+
+    def id
+      @jira_ruby_transition.id
+    end
+
+    def to_status
+      Jigit::JiraStatus.new(@jira_ruby_transition.to)
+    end
+  end
+end

data/lib/jigit/version.rb

@@ -0,0 +1,4 @@
+module Jigit
+  VERSION = "1.0.0".freeze
+  DESCRIPTION = "Keep you JIRA issue statuses in sync with what you're doing actually.".freeze
+end

data/spec/fixtures/jigitfile_invalid.yaml

@@ -0,0 +1,2 @@
+localizations_repo: 'bla_bla_bla'
+localizations fake

data/spec/fixtures/jigitfile_valid.yaml

@@ -0,0 +1,5 @@
+in_progress_status: "In Progress"
+other_statuses:
+- "To Do"
+- "In Review"
+host: "myhost.atlassian.net"

data/spec/lib/integration/jigit/core/jigitfile_generator_spec.rb

@@ -0,0 +1,27 @@
+require "jigit/core/jigitfile_generator"
+require "fileutils"
+
+describe Jigit::JigitfileGenerator do
+  after(:each) do
+    FileUtils.rm_rf("spec/fixtures/Jigitfile.yml")
+  end
+
+  describe(".save") do
+    before(:each) do
+      generator = Jigit::JigitfileGenerator.new("spec/fixtures/")
+      generator.write_in_progress_status_name("In Progress")
+      generator.write_other_statuses(["To Do", "In Review", "Done"])
+      generator.write_jira_host("myhost.atlassian.net")
+      generator.save
+    end
+
+    it("writes prepopulated hash into yaml file") do
+      expected_lines = ["---\n", "in_progress_status: In Progress\n", "other_statuses:\n", "- To Do\n", "- In Review\n", "- Done\n", "host: myhost.atlassian.net\n"]
+      actual_lines = []
+      File.foreach("spec/fixtures/Jigitfile.yml") do |line|
+        actual_lines << line
+      end
+      expect(expected_lines).to be == actual_lines
+    end
+  end
+end

data/spec/lib/integration/jigit/core/keychain_storage_spec.rb

@@ -0,0 +1,35 @@
+require "jigit/helpers/keychain_storage"
+
+describe Jigit::KeychainStorage do
+  before(:each) do
+    @keychain = Keychain.create(File.join(Dir.tmpdir, "keychain_storage_spec_#{Time.now.to_i}_#{Time.now.usec}_#{rand(1000)}.keychain"), "pass")
+  end
+
+  after(:each) do
+    @keychain.delete
+  end
+
+  describe "keychain" do
+    let(:service) { "myhost" }
+    let(:account) { "admin" }
+    let(:password) { "123456" }
+    let(:keychain_storage) { Jigit::KeychainStorage.new(@keychain) }
+
+    context("when stores a new item") do
+      it "makes the stored item be available to load" do
+        keychain_storage.save(account, password, service)
+        item = keychain_storage.load_item(service)
+        expect(item.password).to be == password
+        expect(item.account).to be == account
+        expect(item.service).to be == service
+      end
+    end
+
+    context("when stores a duplicated item") do
+      it "doesn't raise an exception" do
+        keychain_storage.save(account, password, service)
+        expect { keychain_storage.save(account, password, service) }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/lib/integration/jigit/git/git_hook_installer_spec.rb

@@ -0,0 +1,66 @@
+require "jigit/git/git_hook_installer"
+require "jigit/git/git_hook"
+require "fileutils"
+
+describe Jigit::GitHookInstaller do
+  describe(".install") do
+    after(:each) do
+      FileUtils.rm_rf("spec/fixtures/git_hook_installer")
+    end
+
+    context("when there is already git hook file") do
+      before(:each) do
+        FileUtils.mkdir_p("spec/fixtures/git_hook_installer/.git/hooks")
+        FileUtils.touch("spec/fixtures/git_hook_installer/.git/hooks/my_hook")
+        FileUtils.chmod("u=xwr", "spec/fixtures/git_hook_installer/.git/hooks/my_hook")
+        File.open("spec/fixtures/git_hook_installer/.git/hooks/my_hook", "r+") do |f|
+          f.puts("First line")
+        end
+
+        git_hook = double(Jigit::GitHook)
+        allow(git_hook).to receive(:hook_lines).and_return(["Second line", "Third line"])
+        allow(git_hook).to receive(:name).and_return("my_hook")
+
+        @subject = Jigit::GitHookInstaller.new("spec/fixtures/git_hook_installer/.git/hooks",
+                                               "spec/fixtures/git_hook_installer/.git")
+        @subject.install(git_hook)
+      end
+
+      it("appends the given lines into git hook file") do
+        actual_lines = []
+        expected_lines = ["First line\n", "Second line\n", "Third line\n"]
+        File.foreach("spec/fixtures/git_hook_installer/.git/hooks/my_hook") { |line| actual_lines << line }
+        expect(actual_lines).to be == expected_lines
+      end
+    end
+
+    context("when there is no git hook file") do
+      before(:each) do
+        FileUtils.mkdir_p("spec/fixtures/git_hook_installer/.git")
+
+        git_hook = double(Jigit::GitHook)
+        allow(git_hook).to receive(:hook_lines).and_return(["First line", "Second line"])
+        allow(git_hook).to receive(:name).and_return("my_hook")
+
+        @subject = Jigit::GitHookInstaller.new("spec/fixtures/git_hook_installer/.git/hooks",
+                                               "spec/fixtures/git_hook_installer/.git")
+        @subject.install(git_hook)
+      end
+
+      it("creates the hook file") do
+        expect(File.exist?("spec/fixtures/git_hook_installer/.git/hooks/my_hook")).to be(true)
+      end
+
+      it("writes the given lines into git hook file") do
+        actual_lines = []
+        expected_lines = ["First line\n", "Second line\n"]
+        File.foreach("spec/fixtures/git_hook_installer/.git/hooks/my_hook") { |line| actual_lines << line }
+        expect(expected_lines).to be == actual_lines
+      end
+
+      it("ensures that the git hook file executable") do
+        expect(File.executable?("spec/fixtures/git_hook_installer/.git/hooks/my_hook")).to be(true)
+      end
+    end
+  end
+end

data/spec/lib/integration/jigit/git/git_ignore_updater_spec.rb

@@ -0,0 +1,45 @@
+require "jigit/git/git_ignore_updater"
+require "fileutils"
+
+describe Jigit::GitIgnoreUpdater do
+  describe(".ignore") do
+    after(:each) do
+      FileUtils.rm_rf("spec/fixtures/git_ignore_updater")
+    end
+
+    context("when there is empty .gitignore") do
+      before(:each) do
+        FileUtils.mkdir_p("spec/fixtures/git_ignore_updater")
+        FileUtils.touch("spec/fixtures/git_ignore_updater/.gitignore")
+        @subject = Jigit::GitIgnoreUpdater.new("spec/fixtures/git_ignore_updater/.gitignore")
+        @subject.ignore(".jigit")
+      end
+
+      it("ignores the given line") do
+        actual_lines = []
+        expected_lines = [".jigit\n"]
+        File.foreach("spec/fixtures/git_ignore_updater/.gitignore") { |line| actual_lines << line }
+        expect(actual_lines).to be == expected_lines
+      end
+    end
+
+    context("when there is not empty .gitignore") do
+      before(:each) do
+        FileUtils.mkdir_p("spec/fixtures/git_ignore_updater")
+        FileUtils.touch("spec/fixtures/git_ignore_updater/.gitignore")
+        @subject = Jigit::GitIgnoreUpdater.new("spec/fixtures/git_ignore_updater/.gitignore")
+        File.open("spec/fixtures/git_ignore_updater/.gitignore", "r+") do |f|
+          f.puts(".DS_Store")
+        end
+        @subject.ignore(".jigit")
+      end
+
+      it("ignores the given line") do
+        actual_lines = []
+        expected_lines = [".DS_Store\n", ".jigit\n"]
+        File.foreach("spec/fixtures/git_ignore_updater/.gitignore") { |line| actual_lines << line }
+        expect(actual_lines).to be == expected_lines
+      end
+    end
+  end
+end

data/spec/lib/integration/jigit/jira/jira_api_client_spec.rb

@@ -0,0 +1,154 @@
+require "jigit/jira/jira_api_client"
+require "webmock/rspec"
+
+describe Jigit::JiraAPIClient do
+  let(:config) { object_double(Jigit::JiraConfig) }
+  let(:site_url) { "http://foo:bar@localhost:2990" }
+  let(:jira_client) do
+    basic_client = JIRA::Client.new({ username: "foo", password: "bar", auth_type: :basic, use_ssl: false })
+    basic_client
+  end
+
+  describe("fetch_jira_statuses") do
+    context("when there is HTTP error") do
+      before do
+        stub_request(:get, site_url + "/jira/rest/api/2/status").
+          to_return(status: 405, body: "<html><body>Some HTML</body></html>")
+      end
+
+      it("raises an error") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        expect { jira_api_client.fetch_jira_statuses }.to raise_error "Can not fetch a JIRA statuses: <html><body>Some HTML</body></html>"
+      end
+    end
+
+    context("when there is no statuses") do
+      before do
+        stub_request(:get, site_url + "/jira/rest/api/2/status").
+          to_return(status: 301, body: "{\"errorMessages\":[\"Statuses Do Not Exist\"],\"errors\":{}}")
+      end
+
+      it("returns nil") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        expect { jira_api_client.fetch_jira_statuses }.to raise_error "Can not fetch a JIRA statuses: {\"errorMessages\":[\"Statuses Do Not Exist\"],\"errors\":{}}"
+      end
+    end
+
+    context("when there are statuses") do
+      before do
+        stub_request(:get, site_url + "/jira/rest/api/2/status").
+          to_return(status: 200, body: get_mock_response("statuses.json"))
+      end
+
+      it("returns correct amount of statuses") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        fetched_statuses = jira_api_client.fetch_jira_statuses
+        expect(fetched_statuses.count).to be == 5
+      end
+
+      it("returns wrapped jira statuses") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        fetched_statuses = jira_api_client.fetch_jira_statuses
+        expect(fetched_statuses).to all(be_instance_of(Jigit::JiraStatus))
+      end
+    end
+  end
+
+  describe("fetch_issue_transitions") do
+    let(:jira_issue) do
+      base_issue = JIRA::Resource::Issue.new(jira_client, attrs: {
+        "id" => "10002",
+        "self" => "#{site_url}/jira/rest/api/2/issue/10002",
+        "fields" => {
+          "comment" => { "comments" => [] }
+        }
+      })
+      issue = Jigit::JiraIssue.new(base_issue)
+      issue
+    end
+
+    context("when there is HTTP error") do
+      before do
+        stub_request(:get, site_url + "/jira/rest/api/2/issue/10002/transitions?expand=transitions.fields").
+          to_return(status: 405, body: "<html><body>Some HTML</body></html>")
+      end
+
+      it("raises an error") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        expect { jira_api_client.fetch_issue_transitions(jira_issue) }.to raise_error "Can not fetch JIRA issue transitions: <html><body>Some HTML</body></html>"
+      end
+    end
+
+    context("when there is no transitions") do
+      before do
+        stub_request(:get, site_url + "/jira/rest/api/2/issue/10002/transitions?expand=transitions.fields").
+          to_return(status: 301, body: "{\"errorMessages\":[\"Transitions Do Not Exist\"],\"errors\":{}}")
+      end
+
+      it("raises as error") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        expect { jira_api_client.fetch_issue_transitions(jira_issue) }.to raise_error "Can not fetch JIRA issue transitions: {\"errorMessages\":[\"Transitions Do Not Exist\"],\"errors\":{}}"
+      end
+    end
+
+    context("when there are transitions") do
+      before do
+        stub_request(:get, site_url + "/jira/rest/api/2/issue/10002/transitions?expand=transitions.fields").
+          to_return(status: 200, body: get_mock_response("issue_1002_transitions.json"))
+      end
+
+      it("returns correct amount of transitions") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        fetched_transitions = jira_api_client.fetch_issue_transitions(jira_issue)
+        expect(fetched_transitions.count).to be == 4
+      end
+
+      it("returns wrapped jira transitions") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        fetched_transitions = jira_api_client.fetch_issue_transitions(jira_issue)
+        expect(fetched_transitions).to all(be_instance_of(Jigit::JiraTransition))
+      end
+    end
+  end
+
+  describe("fetch_jira_issue") do
+    let(:issue_name) { "ADT-1" }
+
+    context("when there is HTTP error") do
+      before do
+        stub_request(:get, site_url + "/jira/rest/api/2/search?jql=key%20=%20ADT-1").
+          to_return(status: 405, body: "<html><body>Some HTML</body></html>")
+      end
+
+      it("raises an error") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        expect { jira_api_client.fetch_jira_issue(issue_name) }.to raise_error "Can not fetch a JIRA issue: <html><body>Some HTML</body></html>"
+      end
+    end
+
+    context("when there is no issue") do
+      before do
+        stub_request(:get, site_url + "/jira/rest/api/2/search?jql=key%20=%20ADT-1").
+          to_return(status: 301, body: "{\"errorMessages\":[\"Issue Does Not Exist\"],\"errors\":{}}")
+      end
+
+      it("raises an error") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        expect { jira_api_client.fetch_jira_issue(issue_name) }.to raise_error "Can not fetch a JIRA issue: {\"errorMessages\":[\"Issue Does Not Exist\"],\"errors\":{}}"
+      end
+    end
+
+    context("when there is issue") do
+      before do
+        stub_request(:get, site_url + "/jira/rest/api/2/search?jql=key%20=%20ADT-1").
+          to_return(status: 200, body: get_mock_response("issue.json"))
+      end
+
+      it("returns wrapped jira issue") do
+        jira_api_client = Jigit::JiraAPIClient.new(config, jira_client)
+        fetched_issue = jira_api_client.fetch_jira_issue(issue_name)
+        expect(fetched_issue).to be_instance_of(Jigit::JiraIssue)
+      end
+    end
+  end
+end