lita-pagerduty 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c1976196f33f4a430eff395034fd70aeb5ad0ade
+  data.tar.gz: 59f6a07f7e158675e73c5729241adf9d4dc3bc8c
+SHA512:
+  metadata.gz: dbc56aedef1af70d73ce6bdb4cc50c6794c1e48e446f06e7727567a3f5a8b75a828b609768145c8d0dcd6c063ebae756793d28e694158a041e55de16974678c0
+  data.tar.gz: 5e60c4a48e19be645a661c8e91dfd3cd1e2fb01cbb940f78719d935a14e4245dfe6f1723aa759cb7313440922848c4c2bbc895382353510114dd7b9f1e3cb72d

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rubocop.yml

@@ -0,0 +1,8 @@
+MethodLength:
+  Max: 20
+
+ClassLength:
+  Max: 400
+
+Documentation:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.1.0
+script: bundle exec rake
+before_install:
+  - gem update --system
+services:
+  - redis-server

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Eric Sigler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+# lita-pagerduty
+
+[![Build Status](https://travis-ci.org/esigler/lita-pagerduty.png?branch=master)](https://travis-ci.org/esigler/lita-pagerduty)
+[![Code Climate](https://codeclimate.com/github/esigler/lita-pagerduty.png)](https://codeclimate.com/github/esigler/lita-pagerduty)
+[![Coverage Status](https://coveralls.io/repos/esigler/lita-pagerduty/badge.png?branch=master)](https://coveralls.io/r/esigler/lita-pagerduty?branch=master)
+
+PagerDuty (http://pagerduty.com) handler for checking who's on call, scheduling, ack, resolve, etc.
+
+## Installation
+
+Add lita-pagerduty to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-pagerduty"
+```
+
+## Configuration
+
+Add the following variables to your Lita config file:
+
+``` ruby
+config.handlers.pagerduty.api_key   = ''
+config.handlers.pagerduty.subdomain = ''
+```
+
+## Usage
+
+### Specific incidents
+
+```
+Lita pager incidents all                - Show all open incidents
+Lita pager incidents mine               - Show all open incidents assigned to me
+Lita pager incident <incident ID>       - Show a specific incident
+```
+
+### Incident notes
+
+```
+Lita pager notes <incident ID>          - Show all notes for a specific incident
+```
+
+### Acknowledging an incident
+
+```
+Lita pager ack all                      - Acknowledge all triggered incidents
+Lita pager ack mine                     - Acknowledge all triggered incidents assigned to me
+Lita pager ack <incident ID>            - Acknowledge a specific incident
+```
+
+### Resolving an incident
+
+```
+Lita pager resolve all                  - Resolve all triggered incidents
+Lita pager resolve mine                 - Resolve all triggered incidents assigned to me
+Lita pager resolve <incident ID>        - Resolve a specific incident
+```
+
+### Misc
+
+```
+Lita pager identify <email address>     - Associate your chat user with your email address
+Lita pager forget                       - Remove your chat user / email association
+```
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/lita/handlers/pagerduty.rb

@@ -0,0 +1,401 @@
+require 'lita'
+require 'pagerduty'
+
+module Lita
+  module Handlers
+    class Pagerduty < Handler
+      route(
+        /^who\'s\son\scall\?*$/,
+        :whos_on_call,
+        command: true,
+        help: {
+          'who\'s on call?' =>
+          'Show everyone currently on call (not implemented yet)'
+        }
+      )
+
+      route(
+        /^pager\sincidents\sall$/,
+        :incidents_all,
+        command: true,
+        help: {
+          'pager incidents all' => 'Show all open incidents'
+        }
+      )
+
+      route(
+        /^pager\sincidents\smine$/,
+        :incidents_mine,
+        command: true,
+        help: {
+          'pager incidents mine' => 'Show all open incidents assigned to me'
+        }
+      )
+
+      route(
+        /^pager\sincident\s(\w+)$/,
+        :incident,
+        command: true,
+        help: {
+          'pager incident 1234' => 'Show a specific incident'
+        }
+      )
+
+      route(
+        /^pager\snotes\s(\w+)$/,
+        :notes,
+        command: true,
+        help: {
+          'pager notes 1234' => 'Show all notes for a specific incident'
+        }
+      )
+
+      route(
+        /^pager\snote\s(\w+)\s(.+)$/,
+        :note,
+        command: true,
+        help: {
+          'pager note 1234 some text' =>
+          'Add a note to a specific incident (not implemented yet)'
+        }
+      )
+
+      route(
+        /^pager\sack\sall$/,
+        :ack_all,
+        command: true,
+        help: {
+          'pager ack all' => 'Acknowledge all triggered incidents'
+        }
+      )
+
+      route(
+        /^pager\sack\smine$/,
+        :ack_mine,
+        command: true,
+        help: {
+          'pager ack mine' =>
+          'Acknowledge all triggered incidents assigned to me'
+        }
+      )
+
+      route(
+        /^pager\sack\s(\w+)$/,
+        :ack,
+        command: true,
+        help: {
+          'pager ack 1234' => 'Acknowledge a specific incident'
+        }
+      )
+
+      route(
+        /^pager\sresolve\sall$/,
+        :resolve_all,
+        command: true,
+        help: {
+          'pager resolve all' => 'Resolve all triggered incidents'
+        }
+      )
+
+      route(
+        /^pager\sresolve\smine$/,
+        :resolve_mine,
+        command: true,
+        help: {
+          'pager resolve mine' =>
+          'Resolve all triggered incidents assigned to me'
+        }
+      )
+
+      route(
+        /^pager\sresolve\s(\w+)$/,
+        :resolve,
+        command: true,
+        help: {
+          'pager resolve 1234' => 'Resolve a specific incident'
+        }
+      )
+
+      route(
+        /^pager\sidentify\s(.+)$/,
+        :identify,
+        command: true,
+        help: {
+          'pager identify <email address>' =>
+          'Associate your chat user with your email address'
+        }
+      )
+
+      route(
+        /^pager\sforget$/,
+        :forget,
+        command: true,
+        help: {
+          'pager forget' => 'Remove your chat user / email association'
+        }
+      )
+
+      def self.default_config(config)
+        config.api_key = nil
+        config.subdomain = nil
+      end
+
+      def whos_on_call(response)
+        response.reply('Not implemented yet.')
+      end
+
+      def identify(response)
+        email = response.matches[0][0]
+        stored_email = redis.get("email_#{response.user.id}")
+        if !stored_email
+          redis.set("email_#{response.user.id}", email)
+          response.reply('You have now been identified.')
+        else
+          response.reply('You have already been identified!')
+        end
+      end
+
+      def forget(response)
+        stored_email = redis.get("email_#{response.user.id}")
+        if stored_email
+          redis.del("email_#{response.user.id}")
+          response.reply('Your email has now been forgotten.')
+        else
+          response.reply('No email on record for you.')
+        end
+      end
+
+      def incidents_all(response)
+        incidents = fetch_all_incidents
+        if incidents.count > 0
+          incidents.each do |incident|
+            response.reply("#{incident.id}: " \
+                           "\"#{incident.trigger_summary_data.subject}\", " \
+                           "assigned to: #{incident.assigned_to_user.email}")
+          end
+        else
+          response.reply('No triggered, open, or acknowledged incidents')
+        end
+      end
+
+      def incidents_mine(response)
+        email = redis.get("email_#{response.user.id}")
+        if email
+          incidents = fetch_my_incidents(email)
+          if incidents.count > 0
+            incidents.each do |incident|
+              response.reply("#{incident.id}: " \
+                             "\"#{incident.trigger_summary_data.subject}\", " \
+                             "assigned to: #{incident.assigned_to_user.email}")
+            end
+          else
+            response.reply('You have no triggered, open, or acknowledged ' \
+                           'incidents')
+          end
+        else
+          response.reply('You have not identified yourself (use the help ' \
+                         'command for more info)')
+        end
+      end
+
+      def incident(response)
+        incident_id = response.matches[0][0]
+        incident = fetch_incident(incident_id)
+        if incident != 'No results'
+          response.reply("#{incident_id}: " \
+                         "\"#{incident.trigger_summary_data.subject}\", " \
+                         "assigned to: #{incident.assigned_to_user.email}")
+        else
+          response.reply("#{incident_id}: Incident not found")
+        end
+      end
+
+      def notes(response)
+        incident_id = response.matches[0][0]
+        incident = fetch_incident(incident_id)
+        if incident != 'No results'
+          if incident.notes.notes.count > 0
+            incident.notes.notes.each do |note|
+              response.reply("#{incident_id}: #{note.content} "\
+                             "(#{note.user.email})")
+            end
+          else
+            response.reply("#{incident_id}: No notes")
+          end
+        else
+          response.reply("#{incident_id}: Incident not found")
+        end
+      end
+
+      def note(response)
+        response.reply('Not implemented yet.')
+      end
+
+      def ack_all(response)
+        incidents = fetch_all_incidents
+        if incidents.count > 0
+          completed = []
+          incidents.each do |incident|
+            result = acknowledge_incident(incident.id)
+            if result == "#{incident.id}: Incident acknowledged"
+              completed.push(incident.id)
+            end
+            response.reply("Acknowledged: #{completed.join(",")}")
+          end
+        else
+          response.reply('No triggered, open, or acknowledged incidents')
+        end
+      end
+
+      def ack_mine(response)
+        email = redis.get("email_#{response.user.id}")
+        if email
+          incidents = fetch_my_incidents(email)
+          if incidents.count > 0
+            completed = []
+            incidents.each do |incident|
+              result = acknowledge_incident(incident.id)
+              if result == "#{incident.id}: Incident acknowledged"
+                completed.push(incident.id)
+              end
+              response.reply("Acknowledged: #{completed.join(",")}")
+            end
+          else
+            response.reply('You have no triggered, open, or acknowledged ' \
+                           'incidents')
+          end
+        else
+          response.reply('You have not identified yourself (use the help ' \
+                         'command for more info)')
+        end
+      end
+
+      def ack(response)
+        incident_id = response.matches[0][0]
+        return if incident_id == 'all' || incident_id == 'mine'
+        response.reply(acknowledge_incident(incident_id))
+      end
+
+      def resolve_all(response)
+        incidents = fetch_all_incidents
+        if incidents.count > 0
+          completed = []
+          incidents.each do |incident|
+            result = resolve_incident(incident.id)
+            if result == "#{incident.id}: Incident resolved"
+              completed.push(incident.id)
+            end
+            response.reply("Resolved: #{completed.join(",")}")
+          end
+        else
+          response.reply('No triggered, open, or acknowledged incidents')
+        end
+      end
+
+      def resolve_mine(response)
+        email = redis.get("email_#{response.user.id}")
+        if email
+          incidents = fetch_my_incidents(email)
+          if incidents.count > 0
+            completed = []
+            incidents.each do |incident|
+              result = resolve_incident(incident.id)
+              if result == "#{incident.id}: Incident resolved"
+                completed.push(incident.id)
+              end
+              response.reply("Resolved: #{completed.join(",")}")
+            end
+          else
+            response.reply('You have no triggered, open, or acknowledged ' \
+                           'incidents')
+          end
+        else
+          response.reply('You have not identified yourself (use the help ' \
+                         'command for more info)')
+        end
+      end
+
+      def resolve(response)
+        incident_id = response.matches[0][0]
+        return if incident_id == 'all' || incident_id == 'mine'
+        response.reply(resolve_incident(incident_id))
+      end
+
+      private
+
+      def pd_client
+        if Lita.config.handlers.pagerduty.api_key.nil? ||
+           Lita.config.handlers.pagerduty.subdomain.nil?
+          fail 'Bad config'
+        end
+
+        ::Pagerduty.new(token: Lita.config.handlers.pagerduty.api_key,
+                        subdomain: Lita.config.handlers.pagerduty.subdomain)
+      end
+
+      def fetch_all_incidents
+        client = pd_client
+        list = []
+        # FIXME: Workaround on current PD Gem
+        client.incidents.incidents.each do |incident|
+          list.push(incident) if incident.status != 'resolved'
+        end
+        list
+      end
+
+      def fetch_my_incidents(email)
+        # FIXME: Workaround
+        incidents = fetch_all_incidents
+        list = []
+        incidents.each do |incident|
+          list.push(incident) if incident.assigned_to_user.email == email
+        end
+        list
+      end
+
+      def fetch_incident(incident_id)
+        client = pd_client
+        client.get_incident(id: incident_id)
+      end
+
+      def acknowledge_incident(incident_id)
+        incident = fetch_incident(incident_id)
+        if incident != 'No results'
+          if incident.status != 'acknowledged' &&
+             incident.status != 'resolved'
+            results = incident.acknowledge
+            if results.key?('status') && results['status'] == 'acknowledged'
+              "#{incident_id}: Incident acknowledged"
+            else
+              "#{incident_id}: Unable to acknowledge incident"
+            end
+          else
+            "#{incident_id}: Incident already #{incident.status}"
+          end
+        else
+          "#{incident_id}: Incident not found"
+        end
+      end
+
+      def resolve_incident(incident_id)
+        incident = fetch_incident(incident_id)
+        if incident != 'No results'
+          if incident.status != 'resolved'
+            results = incident.resolve
+            if results.key?('status') && results['status'] == 'resolved'
+              "#{incident_id}: Incident resolved"
+            else
+              "#{incident_id}: Unable to resolve incident"
+            end
+          else
+            "#{incident_id}: Incident already #{incident.status}"
+          end
+        else
+          "#{incident_id}: Incident not found"
+        end
+      end
+    end
+
+    Lita.register_handler(Pagerduty)
+  end
+end

data/lib/lita-pagerduty.rb

@@ -0,0 +1 @@
+require 'lita/handlers/pagerduty'

data/lita-pagerduty.gemspec

@@ -0,0 +1,25 @@
+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.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.add_runtime_dependency "lita", ">= 3.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"
+end

data/locales/en.yml

@@ -0,0 +1,4 @@
+en:
+  lita:
+    handlers:
+      pagerduty:

data/spec/lita/handlers/pagerduty_spec.rb

@@ -0,0 +1,457 @@
+require 'spec_helper'
+require 'pagerduty'
+
+describe Lita::Handlers::Pagerduty, lita_handler: true 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(
+        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(:incident_with_notes) 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: [double(content: 'Hi!',
+                         user: double(email: 'foo@example.com'))]
+        )
+      )
+    end
+    client
+  end
+
+  it { routes_command('who\'s on call').to(:whos_on_call) }
+  it { routes_command('who\'s on call?').to(:whos_on_call) }
+  it { routes_command('pager identify foobar@example.com').to(:identify) }
+  it { routes_command('pager forget').to(:forget) }
+  it { routes_command('pager incidents all').to(:incidents_all) }
+  it { routes_command('pager incidents mine').to(:incidents_mine) }
+  it { routes_command('pager incident ABC123').to(:incident) }
+  it { routes_command('pager notes ABC123').to(:notes) }
+  it { routes_command('pager note ABC123 some text').to(:note) }
+  it { routes_command('pager ack all').to(:ack_all) }
+  it { routes_command('pager ack mine').to(:ack_mine) }
+  it { routes_command('pager ack ABC123').to(:ack) }
+  it { routes_command('pager resolve all').to(:resolve_all) }
+  it { routes_command('pager resolve mine').to(:resolve_mine) }
+  it { routes_command('pager resolve ABC123').to(:resolve) }
+
+  describe '.default_config' do
+    it 'sets api_key to nil' do
+      expect(Lita.config.handlers.pagerduty.api_key).to be_nil
+    end
+
+    it 'sets subdomain to nil' do
+      expect(Lita.config.handlers.pagerduty.subdomain).to be_nil
+    end
+  end
+
+  describe 'without valid config' do
+    it 'should error out on any command' do
+      expect { send_command('pager ack ABC123') }.to raise_error('Bad config')
+    end
+  end
+
+  describe 'with valid config' do
+    before do
+      Lita.config.handlers.pagerduty.api_key = 'foo'
+      Lita.config.handlers.pagerduty.subdomain = 'bar'
+    end
+
+    describe '#whos_on_call' do
+      it 'shows a warning' do
+        send_command("who's on call?")
+        expect(replies.last).to eq('Not implemented yet.')
+      end
+    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
+
+    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
+
+    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
+
+    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
+    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
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'simplecov'
+require 'coveralls'
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start { add_filter '/spec/' }
+
+require 'lita-pagerduty'
+require 'lita/rspec'

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: lita-pagerduty
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Eric Sigler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lita
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pagerduty-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Lita handler to interact with PagerDuty
+email:
+- me@esigler.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/lita-pagerduty.rb
+- lib/lita/handlers/pagerduty.rb
+- lita-pagerduty.gemspec
+- locales/en.yml
+- spec/lita/handlers/pagerduty_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/esigler/lita-pagerduty
+licenses:
+- MIT
+metadata:
+  lita_plugin_type: handler
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: A Lita handler to interact with PagerDuty
+test_files:
+- spec/lita/handlers/pagerduty_spec.rb
+- spec/spec_helper.rb