jira_cache 0.2.1

data/lib/jira_cache/version.rb

@@ -0,0 +1,3 @@
+module JiraCache
+  VERSION = File.read(File.expand_path('../../../VERSION', __FILE__)).strip
+end

data/lib/jira_cache/webhook_app.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require "sinatra/base"
+require "json"
+require "jira_cache/sync"
+
+module JiraCache
+
+  # A Sinatra::Base application to process JIRA webhooks.
+  #
+  # Defines 2 routes:
+  #   - GET /: provides a basic JSON status,
+  #   - POST /: which processes a webhook.
+  class WebhookApp < Sinatra::Base
+
+    # GET /
+    # Returns JSON with the app name and a status
+    get "/" do
+      default_response
+    end
+
+    # POST /
+    # Endpoint for JIRA webhook
+    post "/" do
+      client = self.class.client
+      request.body.rewind # in case it was already read
+      data = JSON.parse(request.body.read)
+      issue_key = data["issue"]["key"]
+
+      case (webhook_event = data["webhookEvent"])
+      when "jira:issue_created", "jira:issue_updated", "jira:worklog_updated"
+        JiraCache::Sync.new(client).sync_issue(issue_key)
+      when "jira:issue_deleted"
+        JiraCache::Sync.new.mark_deleted([issue_key])
+      else
+        raise "Unknown webhook event \"#{webhook_event}\""
+      end
+
+      default_response
+    end
+
+    # Returns the client (`JiraCache::Client`) defined on
+    # the class (see `JiraCache.webhook_app(...)`).
+    def client
+      self.class.client
+    end
+
+    def default_response
+      {
+        app: "jira_cache/webhook_app",
+        status: "ok",
+        client: client.info
+      }.to_json
+    end
+  end
+end

data/spec/fixtures/responses/get_issue_keys_jql_query_project=/"multiple_requests/"_start_at_0.json

@@ -0,0 +1 @@
+{"expand":"schema,names","startAt":0,"maxResults":5,"total":11,"issues":[{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"001","self":"https://example.com/rest/api/2/issue/001","key":"MR-001"},{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"002","self":"https://example.com/rest/api/2/issue/002","key":"MR-002"},{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"003","self":"https://example.com/rest/api/2/issue/003","key":"MR-003"},{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"004","self":"https://example.com/rest/api/2/issue/004","key":"MR-004"},{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"005","self":"https://example.com/rest/api/2/issue/005","key":"MR-005"}]}

data/spec/fixtures/responses/get_issue_keys_jql_query_project=/"multiple_requests/"_start_at_10.json

@@ -0,0 +1 @@
+{"expand":"schema,names","startAt":10,"maxResults":5,"total":11,"issues":[{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"011","self":"https://example.com/rest/api/2/issue/011","key":"MR-011"}]}

data/spec/fixtures/responses/get_issue_keys_jql_query_project=/"multiple_requests/"_start_at_5.json

@@ -0,0 +1 @@
+{"expand":"schema,names","startAt":5,"maxResults":5,"total":11,"issues":[{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"006","self":"https://example.com/rest/api/2/issue/006","key":"MR-006"},{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"007","self":"https://example.com/rest/api/2/issue/007","key":"MR-007"},{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"008","self":"https://example.com/rest/api/2/issue/008","key":"MR-008"},{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"009","self":"https://example.com/rest/api/2/issue/009","key":"MR-009"},{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"010","self":"https://example.com/rest/api/2/issue/010","key":"MR-010"}]}

data/spec/fixtures/responses/get_issue_keys_jql_query_project=/"single_request/"_start_at_0.json

@@ -0,0 +1 @@
+{"expand":"schema,names","startAt":0,"maxResults":5,"total":2,"issues":[{"expand":"operations,versionedrepresentations,editmeta,changelog,transitions,renderedfields","id":"001","self":"https://example.com/rest/api/2/issue/001","key":"MR-001"},{"expand":"operations,versionedRepresentations,editmeta,changelog,transitions,renderedFields","id":"002","self":"https://example.com/rest/api/2/issue/002","key":"MR-002"}]}

data/spec/fixtures/responses/get_issue_many_worklogs.json

@@ -0,0 +1 @@
+{"fields":{"worklog":{"total":"3","maxResults":"2","worklogs":["fakeWorklog1","fakeWorklog2"]}}}

data/spec/fixtures/responses/get_issue_not_found.json

@@ -0,0 +1 @@
+{"errorMessages":["Issue Does Not Exist"],"errors":{}}

data/spec/fixtures/responses/get_issue_simple.json

@@ -0,0 +1 @@
+{"fields":{"worklog":{"total":"1","maxResults":"2"}}}

data/spec/fixtures/responses/get_issue_worklog_many_worklogs.json

@@ -0,0 +1 @@
+{"total":"3","maxResults":"3","worklogs":["fakeWorklog1","fakeWorklog2","fakeWorklog3"]}

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+# Load dependencies
+require "rubygems"
+require "bundler/setup"
+require "rspec"
+require "webmock/rspec"
+require "rack/test"
+require "pry"
+
+require "simplecov"
+SimpleCov.start do
+  add_filter do |src|
+    # Ignoring files from the spec directory
+    src.filename =~ %r{/spec/}
+  end
+end
+
+# ENV["APP_ENV"] replaces "RACK_ENV" since we're not in
+# a Rack context.
+ENV["APP_ENV"] = "test"
+require File.expand_path("../../config/boot", __FILE__)
+
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each { |f| require(f) }
+
+# Database setup, teardown and cleanup during tests
+require "sequel/extensions/migration"
+require "jira_cache/data"
+require "jira_cache/data/issue_repository"
+client = JiraCache::Data::DB
+
+MIGRATIONS_DIR = File.expand_path("../../config/db_migrations", __FILE__)
+RSpec.configure do |config|
+
+  config.before(:all) do
+    Sequel::Migrator.apply(client, MIGRATIONS_DIR)
+  end
+
+  config.after(:each) do
+    JiraCache::Data::IssueRepository.delete_where("TRUE")
+  end
+
+  config.after(:all) do
+    Sequel::Migrator.apply(client, MIGRATIONS_DIR, 0)
+  end
+end
+
+require "jira_cache"

data/spec/support/response_fixture.rb

@@ -0,0 +1,16 @@
+# Saves and loads response to be used as fixtures for HTTP request
+# responses.
+class ResponseFixture
+
+  def self.create(identifier, payload)
+    File.write(file(identifier), payload.to_json)
+  end
+
+  def self.get(identifier)
+    File.read(file(identifier))
+  end
+
+  def self.file(identifier)
+    File.expand_path("../../fixtures/responses/#{identifier}.json", __FILE__)
+  end
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "jira_cache/client"
+require "support/response_fixture"
+require "webmock/rspec"
+
+describe JiraCache::Client do
+  let(:domain) { "example.com" }
+  let(:username) { "username" }
+  let(:password) { "password" }
+  let(:notifier) { nil }
+
+  let(:client) do
+    described_class.new(
+      domain: domain,
+      username: username,
+      password: password,
+      notifier: notifier
+    )
+  end
+
+  describe "#issue_data(id_or_key)" do
+    let(:response) { ResponseFixture.get("get_issue_#{issue_key}") }
+    let(:headers) do
+      {
+        "Content-Type" => "application/json",
+        "Authorization" => "Basic dXNlcm5hbWU6cGFzc3dvcmQ="
+      }
+    end
+    let(:url) { "https://#{domain}/rest/api/2/issue/#{issue_key}" }
+    let(:url_query) { "?expand=renderedFields,changelog" }
+
+    before do
+      stub_request(:get, "#{url}#{url_query}")
+        .with(headers: headers)
+        .to_return(status: 200, body: response, headers: headers)
+    end
+
+    context "issue not found" do
+      let(:issue_key) { "not_found" }
+
+      it "returns nil" do
+        result = client.issue_data(issue_key)
+        expect(result).to be_nil
+      end
+    end
+
+    context 'simple issue' do
+      let(:issue_key) { 'simple' }
+      let(:notifier) { double('Notifier', publish: nil) }
+      let(:issue_data) { JSON.parse(response) }
+
+      it 'fetches the issue data' do
+        result = client.issue_data(issue_key)
+        expect(result.keys).to include('fields')
+      end
+
+      it 'publish an event through the notifier' do
+        expect(notifier).to receive(:publish).with('fetched_issue', key: issue_key, data: issue_data)
+        client.issue_data(issue_key)
+      end
+    end
+
+    context 'issue with lots of worklog' do
+      let(:issue_key) { 'many_worklogs' }
+
+      it 'fetches all worklogs' do
+        worklog_response = ResponseFixture.get("get_issue_worklog_#{issue_key}")
+        stub_request(:get, "#{url}/worklog")
+          .with(headers: headers)
+          .to_return(status: 200, body: worklog_response, headers: headers)
+
+        result = client.issue_data(issue_key)
+        expect(result['fields']['worklog']['worklogs'].count).to eq(3)
+      end
+    end
+  end
+
+  describe "#issue_keys_for_query(jql_query)" do
+
+    context "single request query" do
+      let(:jql_query) { 'project="single_request"' }
+      # let(:jql_query) { 'project="JT"' }
+
+      it "returns ids from the query results" do
+        url = "https://#{domain}/rest/api/2/search"
+        url_query = "?fields=id&jql=#{jql_query}&maxResults=1000&startAt=0"
+        headers = { "Content-Type" => "application/json" }
+        response = ResponseFixture.get('get_issue_keys_jql_query_project="single_request"_start_at_0')
+
+        stub_request(:get, "#{url}#{url_query}")
+          .with(headers: headers)
+          .to_return(status: 200, body: response, headers: headers)
+
+        result = client.issue_keys_for_query(jql_query)
+        expect(result.count).to eq(2)
+      end
+    end
+
+    context "query spanning over multiple requests" do
+      let(:jql_query) { 'project="multiple_requests"' }
+
+      it "returns ids from the multiple requests" do
+        url = "https://#{domain}/rest/api/2/search"
+        url_query_1 = "?fields=id&jql=#{jql_query}&maxResults=1000&startAt=0"
+        url_query_2 = "?fields=id&jql=#{jql_query}&maxResults=1000&startAt=5"
+        url_query_3 = "?fields=id&jql=#{jql_query}&maxResults=1000&startAt=10"
+        headers = { "Content-Type" => "application/json" }
+
+        response_fixture_prefix = 'get_issue_keys_jql_query_project="multiple_requests"_start_at_'
+        response_1 = ResponseFixture.get("#{response_fixture_prefix}0")
+        response_2 = ResponseFixture.get("#{response_fixture_prefix}5")
+        response_3 = ResponseFixture.get("#{response_fixture_prefix}10")
+
+        stub_request(:get, "#{url}#{url_query_1}")
+          .with(headers: headers)
+          .to_return(status: 200, body: response_1, headers: headers)
+        stub_request(:get, "#{url}#{url_query_2}")
+          .with(headers: headers)
+          .to_return(status: 200, body: response_2, headers: headers)
+        stub_request(:get, "#{url}#{url_query_3}")
+          .with(headers: headers)
+          .to_return(status: 200, body: response_3, headers: headers)
+
+        result = client.issue_keys_for_query(jql_query)
+        expect(result.count).to eq(11)
+      end
+    end
+  end
+end

data/spec/unit/data/issue_repository_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "timecop"
+require "jira_cache/data/issue_repository"
+
+describe JiraCache::Data::IssueRepository do
+  let(:time) { Time.now }
+  let(:issue1_data) { { "key" => "key1", "fields" => { "project" => { "key" => "PJ1" } }, "value" => "value1" } }
+  let(:issue2_data) { { "key" => "key2", "fields" => { "project" => { "key" => "PJ2" } }, "value" => "value2" } }
+  let(:issue3_data) { { "key" => "key3", "fields" => { "project" => { "key" => "PJ1" } }, "value" => "value3" } }
+
+  before do
+    Timecop.freeze(time)
+    described_class.insert(key: "key1", data: issue1_data, synced_at: time)
+    described_class.insert(key: "key2", data: issue2_data, synced_at: time)
+    described_class.insert(key: "key3", data: issue3_data, synced_at: time)
+  end
+  after { Timecop.return }
+
+  describe "::find_by_key(issue_key)" do
+
+    context "matching issue exists" do
+      it "returns the issue's attributes" do
+        result = described_class.find_by_key("key1")
+        expect(result[:data]["value"]).to eq("value1")
+      end
+    end
+
+    context "no matching issue" do
+      it "returns nil" do
+        expect(described_class.find_by_key("unknown")).to eq(nil)
+      end
+    end
+  end
+
+  describe "::insert(key:, data:, synced_at:, deleted_from_jira_at: nil)" do
+    context "successful" do
+      let(:key) { SecureRandom.uuid }
+      subject do
+        described_class.insert(key: key, data: issue1_data, synced_at: time)
+      end
+
+      it "returns nil" do
+        expect(subject).to eq(nil)
+      end
+
+      it "created the row" do
+        subject
+        expect(JiraCache::Data::IssueRepository.find_by_key(key)).not_to be_nil
+      end
+    end
+  end
+
+  describe "::keys_in_project(project_key)" do
+    subject { described_class.keys_in_project("PJ1") }
+    it { should eq(%w(key1 key3)) }
+  end
+end

data/spec/unit/notifier_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "jira_cache/notifier"
+
+describe JiraCache::Notifier do
+
+  describe "::published(name, data = nil)" do
+    let(:event_name) { "test" }
+    let(:issue_data) { { "value" => "issue_value", "key" => "issue_data_key" } }
+    let(:event_data) { { key: "issue_key", data: issue_data } }
+
+    it "logs the event name and event\"s data key" do
+      logger = ::Logger.new("/dev/null")
+      notifier = described_class.new(logger)
+      expect(logger).to receive(:info).with("[test] #{event_data[:key]}")
+      notifier.publish event_name, event_data
+    end
+  end
+end

data/spec/unit/sync_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "timecop"
+require "jira_cache/sync"
+
+describe JiraCache::Sync do
+
+  subject { described_class.new(client) }
+  let(:client) { double("JiraCache::Client", issue_data: {}, logger: nil) }
+  let(:now) { Time.now }
+
+  before do
+    Timecop.freeze(now)
+  end
+
+  after { Timecop.return }
+
+  it "has a version number" do
+    expect(JiraCache::VERSION).not_to be nil
+  end
+
+  let(:project_key) { "project_key" }
+  let(:remote_keys) { %w(a b c d) }
+  let(:cached_keys) { %w(c d e f) }
+  let(:updated_keys) { %w(c) }
+  let(:latest_sync_time) { now }
+
+  describe "::sync_issues(project_key: nil)" do
+
+    before do
+      expect(subject)
+        .to receive(:remote_keys)
+        .with(project_key: project_key)
+        .and_return(remote_keys)
+      expect(subject)
+        .to receive(:cached_keys)
+        .with(project_key: project_key)
+        .and_return(cached_keys)
+      expect(subject)
+        .to receive(:updated_keys)
+        .with(project_key: project_key)
+        .and_return(updated_keys)
+    end
+
+    it "fetches new and updated issues" do
+      expect(subject).to receive(:fetch_issues).with(%w(a b c), now)
+      subject.sync_issues(project_key: project_key)
+    end
+
+    it "marks deleted issues" do
+      expect(subject).to receive(:mark_deleted).with(%w(e f))
+      subject.sync_issues(project_key: project_key)
+    end
+
+    it "stores issues with the sync time" do
+      subject.sync_issues(project_key: project_key)
+      expect(JiraCache::Data::IssueRepository.latest_sync_time).to be_within(1).of latest_sync_time
+    end
+  end
+
+  describe "::remote_keys(project_key: nil)" do
+    it "fetches the issue keys for the project" do
+      expect(subject).to receive(:fetch_issue_keys).with(project_key: project_key)
+      subject.remote_keys(project_key: project_key)
+    end
+  end
+
+  describe "::cached_keys(project_key: nil)" do
+    it "fetches keys from cached issues" do
+      expect(JiraCache::Data::IssueRepository)
+        .to receive(:keys_in_project)
+        .with(project_key: project_key)
+      subject.cached_keys(project_key: project_key)
+    end
+  end
+
+  describe "::updated_keys(project_key: nil)" do
+    it "fetch issue keys for the project updated from the last sync date" do
+      expect(subject).to receive(:latest_sync_time).and_return(latest_sync_time)
+      expect(subject).to receive(:fetch_issue_keys).with(project_key: project_key, updated_since: latest_sync_time)
+      subject.updated_keys(project_key: project_key)
+    end
+  end
+
+  describe "::fetch_issue_keys(project_key: nil, updated_since: nil)" do
+
+    context "with no parameter" do
+      it "fetches issue keys with an empty JQL query" do
+        expect(client)
+          .to receive(:issue_keys_for_query)
+          .with("")
+        subject.fetch_issue_keys()
+      end
+    end
+
+    context "with only the `project_key` parameter" do
+      it "fetches issue keys with the project JQL query" do
+        expect(client)
+          .to receive(:issue_keys_for_query)
+          .with("project = \"#{project_key}\"")
+        subject.fetch_issue_keys(project_key: project_key)
+      end
+    end
+
+    context "with both parameters" do
+      it "fetches issue keys with the project and updated_since JQL query" do
+        expected_jql = "project = \"#{project_key}\""
+        expected_jql += " AND updatedDate > \"#{latest_sync_time.strftime('%Y-%m-%d %H:%M')}\""
+        expect(client)
+          .to receive(:issue_keys_for_query)
+          .with(expected_jql)
+        subject.fetch_issue_keys(project_key: project_key, updated_since: latest_sync_time)
+      end
+    end
+  end
+end