lita-pagerduty 0.0.1 → 0.1.0

data/lita-pagerduty.gemspec

@@ -1,25 +1,26 @@
 Gem::Specification.new do |spec|
-  spec.name          = "lita-pagerduty"
-  spec.version       = "0.0.1"
-  spec.authors       = ["Eric Sigler"]
-  spec.email         = ["me@esigler.com"]
-  spec.description   = %q{A Lita handler to interact with PagerDuty}
-  spec.summary       = %q{A Lita handler to interact with PagerDuty}
-  spec.homepage      = "http://github.com/esigler/lita-pagerduty"
-  spec.license       = "MIT"
-  spec.metadata      = { "lita_plugin_type" => "handler" }
+  spec.name          = 'lita-pagerduty'
+  spec.version       = '0.1.0'
+  spec.authors       = ['Eric Sigler']
+  spec.email         = ['eric@pagerduty.com']
+  spec.description   = 'A Lita handler to interact with PagerDuty'
+  spec.summary       = 'A Lita handler to interact with PagerDuty'
+  spec.homepage      = 'http://github.com/esigler/lita-pagerduty'
+  spec.license       = 'MIT'
+  spec.metadata      = { 'lita_plugin_type' => 'handler' }
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(%r{^bin\/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)\/})
+  spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency "lita", ">= 3.0"
-  spec.add_runtime_dependency "pagerduty-sdk"
+  spec.add_runtime_dependency 'lita', '>= 4.0'
+  spec.add_runtime_dependency 'pagerduty-sdk'
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", ">= 3.0.0.beta2"
-  spec.add_development_dependency "simplecov"
-  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '>= 3.0'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
 end

data/locales/en.yml

@@ -2,3 +2,83 @@ en:
   lita:
     handlers:
       pagerduty:
+        error:
+          not_implemented: Not implemented yet.
+        help:
+          ack:
+            syntax: pager ack 1234
+            desc: Acknowledge a specific incident
+          ack_all:
+            syntax: pager ack all
+            desc: Acknowledge all triggered incidents
+          ack_mine:
+            syntax: pager ack mine
+            desc: Acknowledge all triggered incidents assigned to me
+          forget:
+            syntax: pager forget
+            desc: Remove your chat user / email association
+          identify:
+            syntax: pager identify <email address>
+            desc: Associate your chat user with your email address
+          incident:
+            syntax: pager incident 1234
+            desc: Show a specific incident
+          incidents_all:
+            syntax: pager incidents all
+            desc: Show all open incidents
+          incidents_mine:
+            syntax: pager incidents mine
+            desc: Show all open incidents assigned to me
+          note:
+            syntax: pager note 1234 some text
+            desc: Add a note to a specific incident (not implemented yet)
+          notes:
+            syntax: pager notes 1234
+            desc: Show all notes for a specific incident
+          resolve:
+            syntax: pager resolve 1234
+            desc: Resolve a specific incident
+          resolve_all:
+            syntax: pager resolve all
+            desc: Resolve all triggered incidents
+          resolve_mine:
+            syntax: pager resolve mine
+            desc: Resolve all triggered incidents assigned to me
+          on_call_list:
+            syntax: pager oncall
+            desc: List available schedules
+          on_call_lookup:
+            syntax: pager oncall <schedule>
+            desc: Show who is on call for the given schedule
+          whos_on_call:
+            syntax: who's on call?
+            desc: Show everyone currently on call (not implemented yet)
+        identify:
+          already: You have already been identified!
+          complete: You have now been identified.
+          missing: You have not identified yourself (use the help command for more info)
+        incident:
+          acknowledged: "%{id}: Incident acknowledged"
+          already_set: "%{id}: Incident already %{status}"
+          none: No triggered, open, or acknowledged incidents
+          none_mine: You have no triggered, open, or acknowledged incidents
+          not_found: "%{id}: Incident not found"
+          resolved: "%{id}: Incident resolved"
+          unable_to_acknowledge: "%{id}: Unable to acknowledge incident"
+          unable_to_resolve: "%{id}: Unable to resolve incident"
+          info: "%{id}: \"%{subject}\", assigned to: %{assigned}"
+        forget:
+          complete: Your email has now been forgotten.
+          unknown: No email on record for you.
+        all:
+          acknowledged: "Acknowledged: %{list}"
+          resolved: "Resolved: %{list}"
+        note:
+          show: "%{id}: %{content} (%{email})"
+        on_call_list:
+          response: "Available schedules: %{schedules}"
+          no_schedules_found: "No schedules found"
+        on_call_lookup:
+          response: "%{name} (%{email}) is currently on call for %{schedule_name}"
+          no_matching_schedule: "No matching schedules found for '%{schedule_name}'" 
+          no_one_on_call: "No one is currently on call for %{schedule_name}"

data/spec/lita/handlers/pagerduty_ack_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Lita::Handlers::PagerdutyAck, lita_handler: true do
+  include_context 'basic fixtures'
+
+  it do
+    is_expected.to route_command('pager ack all').to(:ack_all)
+    is_expected.to route_command('pager ack mine').to(:ack_mine)
+    is_expected.to route_command('pager ack ABC123').to(:ack)
+  end
+
+  describe '#ack_all' do
+    describe 'when there are acknowledgable incidents' do
+      it 'shows them as acknowledged' do
+        expect(Pagerduty).to receive(:new).twice { incidents }
+        send_command('pager ack all')
+        expect(replies.last).to eq('Acknowledged: ABC789')
+      end
+    end
+
+    describe 'when there are no acknowledgable incidents' do
+      it 'shows a warning' do
+        expect(Pagerduty).to receive(:new) { no_incidents }
+        send_command('pager ack all')
+        expect(replies.last).to eq('No triggered, open, or acknowledged ' \
+                                   'incidents')
+      end
+    end
+  end
+
+  describe '#ack_mine' do
+    describe 'when there are acknowledgable incidents for the user' do
+      it 'shows them as acknowledged' do
+        bar = Lita::User.create(123, name: 'bar')
+        expect(Pagerduty).to receive(:new).twice { incidents }
+        send_command('pager identify bar@example.com', as: bar)
+        send_command('pager ack mine', as: bar)
+        expect(replies.last).to eq('Acknowledged: ABC789')
+      end
+    end
+
+    describe 'when there are no acknowledgable incidents for the user' do
+      it 'shows a warning' do
+        foo = Lita::User.create(123, name: 'foo')
+        expect(Pagerduty).to receive(:new) { incidents }
+        send_command('pager identify foo@example.com', as: foo)
+        send_command('pager ack mine', as: foo)
+        expect(replies.last).to eq('You have no triggered, open, or ' \
+                                   'acknowledged incidents')
+      end
+    end
+
+    describe 'when the user has not identified themselves' do
+      it 'shows a warning' do
+        send_command('pager ack mine')
+        expect(replies.last).to eq('You have not identified yourself (use ' \
+                                   'the help command for more info)')
+      end
+    end
+  end
+
+  describe '#ack' do
+    describe 'when the incident has not been acknowledged' do
+      it 'shows the acknowledgement' do
+        expect(Pagerduty).to receive(:new) { new_incident }
+        send_command('pager ack ABC123')
+        expect(replies.last).to eq('ABC123: Incident acknowledged')
+      end
+    end
+
+    describe 'when the incident has already been acknowledged' do
+      it 'shows the warning' do
+        expect(Pagerduty).to receive(:new) { acknowledged_incident }
+        send_command('pager ack ABC123')
+        expect(replies.last).to eq('ABC123: Incident already acknowledged')
+      end
+    end
+
+    describe 'when the incident does not exist' do
+      it 'shows an error' do
+        expect(Pagerduty).to receive(:new) { no_incident }
+        send_command('pager ack ABC123')
+        expect(replies.last).to eq('ABC123: Incident not found')
+      end
+    end
+
+    describe 'when the incident cannot be acknowledged' do
+      it 'shows that its unable to acknowledge' do
+        expect(Pagerduty).to receive(:new) { unable_to_ack_incident }
+        send_command('pager ack ABC123')
+        expect(replies.last).to eq('ABC123: Unable to acknowledge incident')
+      end
+    end
+  end
+end

data/spec/lita/handlers/pagerduty_incident_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Lita::Handlers::PagerdutyIncident, lita_handler: true do
+  include_context 'basic fixtures'
+
+  it do
+    is_expected.to route_command('pager incidents all').to(:incidents_all)
+    is_expected.to route_command('pager incidents mine').to(:incidents_mine)
+    is_expected.to route_command('pager incident ABC123').to(:incident)
+  end
+
+  describe '#incidents_all' do
+    describe 'when there are open incidents' do
+      it 'shows a list of incidents' do
+        expect(Pagerduty).to receive(:new) { incidents }
+        send_command('pager incidents all')
+        expect(replies.last).to eq('ABC789: "Still broke", assigned to: '\
+                                   'bar@example.com')
+      end
+    end
+
+    describe 'when there are no open incidents' do
+      it 'shows a warning' do
+        expect(Pagerduty).to receive(:new) { no_incidents }
+        send_command('pager incidents all')
+        expect(replies.last).to eq('No triggered, open, or acknowledged ' \
+                                   'incidents')
+      end
+    end
+  end
+
+  describe '#incidents_mine' do
+    describe 'when there are open incidents for the user' do
+      it 'shows a list of incidents' do
+        bar = Lita::User.create(123, name: 'bar')
+        expect(Pagerduty).to receive(:new) { incidents }
+        send_command('pager identify bar@example.com', as: bar)
+        send_command('pager incidents mine', as: bar)
+        expect(replies.last).to eq('ABC789: "Still broke", assigned to: ' \
+                                   'bar@example.com')
+      end
+    end
+
+    describe 'when there are no open incidents for the user' do
+      it 'shows no incidents' do
+        foo = Lita::User.create(123, name: 'foo')
+        expect(Pagerduty).to receive(:new) { incidents }
+        send_command('pager identify foo@example.com', as: foo)
+        send_command('pager incidents mine', as: foo)
+        expect(replies.last).to eq('You have no triggered, open, or ' \
+                                   'acknowledged incidents')
+      end
+    end
+
+    describe 'when the user has not identified themselves' do
+      it 'shows a warning' do
+        send_command('pager incidents mine')
+        expect(replies.last).to eq('You have not identified yourself (use ' \
+                                   'the help command for more info)')
+      end
+    end
+  end
+
+  describe '#incident' do
+    describe 'when the incident exists' do
+      it 'shows incident details' do
+        expect(Pagerduty).to receive(:new) { new_incident }
+        send_command('pager incident ABC123')
+        expect(replies.last).to eq('ABC123: "something broke", ' \
+                                   'assigned to: foo@example.com')
+      end
+    end
+
+    describe 'when the incident does not exist' do
+      it 'shows an error' do
+        expect(Pagerduty).to receive(:new) { no_incident }
+        send_command('pager incident ABC123')
+        expect(replies.last).to eq('ABC123: Incident not found')
+      end
+    end
+  end
+end

data/spec/lita/handlers/pagerduty_note_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Lita::Handlers::PagerdutyNote, lita_handler: true do
+  include_context 'basic fixtures'
+
+  it do
+    is_expected.to route_command('pager notes ABC123').to(:notes)
+    is_expected.to route_command('pager note ABC123 some text').to(:note)
+  end
+
+  describe '#notes' do
+    describe 'when the incident has notes' do
+      it 'shows incident notes' do
+        expect(Pagerduty).to receive(:new) { incident_with_notes }
+        send_command('pager notes ABC123')
+        expect(replies.last).to eq('ABC123: Hi! (foo@example.com)')
+      end
+    end
+
+    describe 'when the incident doesnt have notes' do
+      it 'shows no notes' do
+        expect(Pagerduty).to receive(:new) { new_incident }
+        send_command('pager notes ABC123')
+        expect(replies.last).to eq('ABC123: No notes')
+      end
+    end
+
+    describe 'when the incident does not exist' do
+      it 'shows an error' do
+        expect(Pagerduty).to receive(:new) { no_incident }
+        send_command('pager notes ABC123')
+        expect(replies.last).to eq('ABC123: Incident not found')
+      end
+    end
+  end
+
+  describe '#note' do
+    it 'shows a warning' do
+      send_command('pager note ABC123 some text')
+      expect(replies.last).to eq('Not implemented yet.')
+    end
+  end
+end

data/spec/lita/handlers/pagerduty_resolve_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Lita::Handlers::PagerdutyResolve, lita_handler: true do
+  include_context 'basic fixtures'
+
+  it do
+    is_expected.to route_command('pager resolve all').to(:resolve_all)
+    is_expected.to route_command('pager resolve mine').to(:resolve_mine)
+    is_expected.to route_command('pager resolve ABC123').to(:resolve)
+  end
+
+  describe '#resolve_all' do
+    describe 'when there are resolvable incidents' do
+      it 'shows them as resolved' do
+        expect(Pagerduty).to receive(:new).twice { incidents }
+        send_command('pager resolve all')
+        expect(replies.last).to eq('Resolved: ABC789')
+      end
+    end
+
+    describe 'when there are no resolvable incidents' do
+      it 'shows a warning' do
+        expect(Pagerduty).to receive(:new) { no_incidents }
+        send_command('pager resolve all')
+        expect(replies.last).to eq('No triggered, open, or acknowledged ' \
+                                   'incidents')
+      end
+    end
+  end
+
+  describe '#resolve_mine' do
+    describe 'when there are resolvable incidents for the user' do
+      it 'shows them as acknowledged' do
+        bar = Lita::User.create(123, name: 'bar')
+        expect(Pagerduty).to receive(:new).twice { incidents }
+        send_command('pager identify bar@example.com', as: bar)
+        send_command('pager resolve mine', as: bar)
+        expect(replies.last).to eq('Resolved: ABC789')
+      end
+    end
+
+    describe 'when there are no resolvable incidents for the user' do
+      it 'shows a warning' do
+        foo = Lita::User.create(123, name: 'foo')
+        expect(Pagerduty).to receive(:new) { incidents }
+        send_command('pager identify foo@example.com', as: foo)
+        send_command('pager resolve mine', as: foo)
+        expect(replies.last).to eq('You have no triggered, open, or ' \
+                                   'acknowledged incidents')
+      end
+    end
+
+    describe 'when the user has not identified themselves' do
+      it 'shows a warning' do
+        send_command('pager resolve mine')
+        expect(replies.last).to eq('You have not identified yourself (use ' \
+                                   'the help command for more info)')
+      end
+    end
+  end
+
+  describe '#resolve' do
+    describe 'when the incident has not been resolved' do
+      it 'shows the resolve' do
+        expect(Pagerduty).to receive(:new) { new_incident }
+        send_command('pager resolve ABC123')
+        expect(replies.last).to eq('ABC123: Incident resolved')
+      end
+    end
+
+    describe 'when the incident has already been resolved' do
+      it 'shows the warning' do
+        expect(Pagerduty).to receive(:new) { resolved_incident }
+        send_command('pager resolve ABC123')
+        expect(replies.last).to eq('ABC123: Incident already resolved')
+      end
+    end
+
+    describe 'when the incident does not exist' do
+      it 'shows an error' do
+        expect(Pagerduty).to receive(:new) { no_incident }
+        send_command('pager resolve ABC123')
+        expect(replies.last).to eq('ABC123: Incident not found')
+      end
+    end
+
+    describe 'when the incident cannot be resolved' do
+      it 'shows an error' do
+        expect(Pagerduty).to receive(:new) { unable_to_resolve_incident }
+        send_command('pager resolve ABC123')
+        expect(replies.last).to eq('ABC123: Unable to resolve incident')
+      end
+    end
+  end
+end

data/spec/lita/handlers/pagerduty_utility_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Lita::Handlers::PagerdutyUtility, lita_handler: true do
+  include_context 'basic fixtures'
+
+  it do
+    is_expected.to route_command('pager oncall').to(:on_call_list)
+    is_expected.to route_command('pager oncall ops').to(:on_call_lookup)
+    is_expected.to route_command('pager identify foobar@example.com').to(:identify)
+    is_expected.to route_command('pager forget').to(:forget)
+  end
+
+  before do
+    Lita.config.handlers.pagerduty.api_key = 'foo'
+    Lita.config.handlers.pagerduty.subdomain = 'bar'
+  end
+
+  describe '#identify' do
+    describe 'when that email is new' do
+      it 'shows a successful identification' do
+        foo = Lita::User.create(123, name: 'foo')
+        send_command('pager identify foo@example.com', as: foo)
+        expect(replies.last).to eq('You have now been identified.')
+      end
+    end
+
+    # TODO: It'd be great to validate this against the existing
+    # users on the PD account.
+
+    describe 'when that email exists already' do
+      it 'shows a warning' do
+        baz = Lita::User.create(321, name: 'baz')
+        send_command('pager identify baz@example.com', as: baz)
+        send_command('pager identify baz@example.com', as: baz)
+        expect(replies.last).to eq('You have already been identified!')
+      end
+    end
+  end
+
+  describe '#forget' do
+    describe 'when that user is associated' do
+      it 'shows a successful forget' do
+        foo = Lita::User.create(123, name: 'foo')
+        send_command('pager identify foo@example.com', as: foo)
+        send_command('pager forget', as: foo)
+        expect(replies.last).to eq('Your email has now been forgotten.')
+      end
+    end
+
+    describe 'when that user is not associated' do
+      it 'shows a warning' do
+        foo = Lita::User.create(123, name: 'foo')
+        send_command('pager forget', as: foo)
+        expect(replies.last).to eq('No email on record for you.')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -8,3 +8,152 @@ SimpleCov.start { add_filter '/spec/' }
 
 require 'lita-pagerduty'
 require 'lita/rspec'
+
+Lita.version_3_compatibility_mode = false
+
+RSpec.configure do |config|
+  config.before do
+    registry.register_handler(Lita::Handlers::PagerdutyAck)
+    registry.register_handler(Lita::Handlers::PagerdutyIncident)
+    registry.register_handler(Lita::Handlers::PagerdutyNote)
+    registry.register_handler(Lita::Handlers::PagerdutyResolve)
+    registry.register_handler(Lita::Handlers::PagerdutyUtility)
+  end
+end
+
+RSpec.shared_context 'basic fixtures' do
+  let(:no_incident) do
+    client = double
+    expect(client).to receive(:get_incident) { 'No results' }
+    client
+  end
+
+  let(:no_incidents) do
+    client = double
+    expect(client).to receive(:incidents) do
+      double(
+        incidents: []
+      )
+    end
+    client
+  end
+
+  let(:incidents) do
+    client = double
+    expect(client).to receive(:incidents) do
+      double(
+        incidents: [
+          double(
+            id: 'ABC123',
+            status: 'resolved',
+            trigger_summary_data: double(subject: 'something broke'),
+            assigned_to_user: double(email: 'foo@example.com')
+          ),
+          double(
+            id: 'ABC789',
+            status: 'triggered',
+            trigger_summary_data: double(subject: 'Still broke'),
+            assigned_to_user: double(email: 'bar@example.com')
+          )
+        ]
+      )
+    end
+    allow(client).to receive(:get_incident) do
+      double(
+        status: 'triggered',
+        trigger_summary_data: double(subject: 'Still broke'),
+        assigned_to_user: double(email: 'bar@example.com'),
+        acknowledge: { 'id' => 'ABC789', 'status' => 'acknowledged' },
+        resolve: { 'id' => 'ABC789', 'status' => 'resolved' },
+        notes: double(notes: [])
+      )
+    end
+    client
+  end
+
+  let(:new_incident) do
+    client = double
+    expect(client).to receive(:get_incident) do
+      double(
+        id: 'ABC123',
+        status: 'triggered',
+        trigger_summary_data: double(subject: 'something broke'),
+        assigned_to_user: double(email: 'foo@example.com'),
+        acknowledge: { 'id' => 'ABC123', 'status' => 'acknowledged' },
+        resolve: { 'id' => 'ABC123', 'status' => 'resolved' },
+        notes: double(notes: [])
+      )
+    end
+    client
+  end
+
+  let(:acknowledged_incident) do
+    client = double
+    expect(client).to receive(:get_incident) do
+      double(
+        status: 'acknowledged',
+        trigger_summary_data: double(subject: 'something broke'),
+        assigned_to_user: double(email: 'foo@example.com'),
+        acknowledge: { 'error' =>
+          { 'message' => 'Incident Already Acknowledged', 'code' => 1002 }
+        },
+        resolve:  { 'id' => 'ABC123', 'status' => 'resolved' },
+        notes: double(notes: [])
+      )
+    end
+    client
+  end
+
+  let(:resolved_incident) do
+    client = double
+    expect(client).to receive(:get_incident) do
+      double(
+        status: 'resolved',
+        trigger_summary_data: double(subject: 'something broke'),
+        assigned_to_user: double(email: 'foo@example.com'),
+        notes: double(notes: [])
+      )
+    end
+    client
+  end
+
+  let(:unable_to_resolve_incident) do
+    client = double
+    expect(client).to receive(:get_incident) do
+      double(
+        status: 'notresolved',
+        resolve:  { 'id' => 'ABC123', 'status' => 'notresolved' }
+      )
+    end
+    client
+  end
+
+  let(:unable_to_ack_incident) do
+    client = double
+    expect(client).to receive(:get_incident) do
+      double(
+        status: 'notacked',
+        acknowledge: { 'error' => {} },
+        resolve:  { 'id' => 'ABC123', 'status' => 'notacked' }
+      )
+    end
+    client
+  end
+
+  let(:incident_with_notes) do
+    client = double
+    expect(client).to receive(:get_incident) do
+      double(
+        id: 'ABC123',
+        status: 'resolved',
+        trigger_summary_data: double(subject: 'something broke'),
+        assigned_to_user: double(email: 'foo@example.com'),
+        notes: double(
+          notes: [double(content: 'Hi!',
+                         user: double(email: 'foo@example.com'))]
+        )
+      )
+    end
+    client
+  end
+end