lita-github 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e0d281bcf8adc83548ac483d406f19672414bde
-  data.tar.gz: 0324546f1f50adb9f70c9836ded9df84a18aaeba
+  metadata.gz: 2def5b26a94d3e8cc55f5c8da28109c7c04283a6
+  data.tar.gz: 019e7d005d5fa98459bd5fb36fcc24e1b36d34b9
 SHA512:
-  metadata.gz: 4203c3537cd0084bb131f74ba86fc11f8dc01f2e0f6b8c319fb5e7d602e5999d2e206b123fb8f50aa4ee909d2f0492c7d0a7fb5e78755d698d0deb57317a711b
-  data.tar.gz: 257b7734d642160b36f18fa567183da9bf2fb650d6f88efaad8b18d4e49c8d3d0beeec618e2569fd0dcf5261537641621e73ffad58dda3a96f53fc4fae7cde25
+  metadata.gz: 6afe9d22373957f410bb03af8530a367d00f81ebca9ec55d3cb5d698ae50d6cb55b89c05f85076ce21399d45200e5a95045f09e3dfa52c1c2fc610832a2dfa2f
+  data.tar.gz: bc8bf0a906252b8fc026e10ef798ac65a110c6be0ab99ccfdd664c688a2f43d4f244b106b2e3c66eabd220865a6671ef46f0cc236f2deb39f94c647e009a64a7

data/.travis.yml

@@ -1,14 +1,13 @@
 branches:
   only:
     - master
+sudo: false
 env: CODECLIMATE_REPO_TOKEN=3ffc4d9148b686fd07872259719fc6458a5521213e73e1f7b9db8546292f622a
 services:
   - redis-server
 language: ruby
 rvm:
+  - 2.2.2
+  - 2.2.1
   - 2.1.5
   - 2.1.4
-  - 2.1.3
-  - 2.1.2
-  - 2.1.1
-  - 2.1.0

data/README.md

@@ -22,14 +22,14 @@ Configuration
 The configuration options will get their own in-depth doc a little further down the line. Here are the important ones for now:
 
 * `config.handlers.github.access_token = ''`
-  * Your GitHUb access token (generated from Settings > Security > Personal Applications)
+  * Your GitHub access token (generated from Settings > Security > Personal Applications)
   * This is an administrative utility, so the token will need pretty wide access to leverage this plugin fully
 * `config.handlers.github.default_org = ''`
   * Your company may only have one organization, the handler will allow you to type just the repo name (`lita-github`) instead of `PagerDuty/lita-github`.
-* `config.handlers.github.default_team_slug = ''`
-  * if no team is provided when adding a repo, it uses this team by default -- if unset, only owners can access repo
-  * the default team that should be added to a repo based on the slug name:
-    * When clicking on a team in your org you can use the URL to get the slug: https://github.com/orgs/<ORG>/teams/[slug]
+  * `config.handlers.github.default_team_slugs = ['']`
+    * if no team is provided when adding a repo, it uses these teams by default -- if unset, only owners can access repo
+    * the default teams that should be added to a repo based on the slug name:
+      * When clicking on a team in your org you can use the URL to get the slug: https://github.com/orgs/<ORG>/teams/[slug]
 
 Commands
 --------

data/Rakefile

@@ -14,6 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
 

data/lib/lita-github/version.rb

@@ -21,7 +21,7 @@
 # @author Tim Heckman <tim@pagerduty.com>
 module LitaGithub
   # lita-github version
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 
   # lita-github version split amongst different revisions
   MAJOR_VERSION, MINOR_VERSION, REVISION = VERSION.split('.').map(&:to_i)

data/lib/lita/handlers/github.rb

@@ -68,7 +68,7 @@ module Lita
       def self.default_config(config)
         # when setting default configuration values please remember one thing:
         # secure and safe by default
-        config.default_team_slug          = nil
+        config.default_team_slugs         = nil
         config.repo_private_default       = true
         config.org_team_add_allowed_perms = %w(pull)
 

data/lib/lita/handlers/github_repo.rb

@@ -277,11 +277,14 @@ module Lita
       def extrapolate_create_opts(opts, org)
         opts[:organization] = org
 
-        if opts.key?(:team)
-          t_id = team_id_by_slug(opts[:team], org) || default_team(org)
-          opts[:team_id] = t_id unless t_id.nil?
-        else
-          t_id = default_team(org)
+        first_team, other_teams = filter_teams(default_teams(org))
+
+        begin
+          t_id = team_id_by_slug(opts.fetch(:team), org)
+        rescue KeyError
+          t_id = first_team
+          opts[:other_teams] = other_teams unless other_teams.empty?
+        ensure
           opts[:team_id] = t_id unless t_id.nil?
         end unless opts.key?(:team_id)
 
@@ -290,8 +293,17 @@ module Lita
         opts
       end
 
-      def default_team(org)
-        config.default_team_slug.nil? ? nil : team_id_by_slug(config.default_team_slug, org)
+      def filter_teams(teams)
+        [teams.first, teams[1..-1].reject(&:nil?)] # Filter invalid team IDs
+      end
+
+      def default_teams(org)
+        teams = config.default_team_slugs
+        # If default_team_slugs is either a non-array (e.g. nil) or an empty
+        # array, return an array containing nil
+        return [nil] if !teams.is_a?(Array) || teams.empty?
+        # If it's a populated array, return an array of corresponding team IDs
+        teams.map { |team| team_id_by_slug(team, org) }
       end
 
       def should_repo_be_private?(value)
@@ -308,7 +320,7 @@ module Lita
           true
         when 'false'
           false
-        else # when some invalud value...
+        else # when some invalid value...
           config.repo_private_default
         end
       end
@@ -318,6 +330,9 @@ module Lita
         reply = nil
         begin
           octo.create_repository(repo, opts)
+          opts[:other_teams].each do |team|
+            add_team_to_repo(full_name, team)
+          end if opts.key?(:other_teams)
         ensure
           if repo?(full_name)
             repo_url = "https://github.com/#{full_name}"

data/spec/unit/lita/handlers/github_issues_spec.rb

@@ -97,9 +97,9 @@ describe Lita::Handlers::GithubIssues, lita_handler: true do
         }
       ]
       @octo_obj = double('Octokit::Client', list_issues: issues)
-      allow(github_issues).to receive(:octo).and_return(@octo_obj)
-      allow(github_issues).to receive(:repo?).and_return(true)
-      allow(github_issues).to receive(:validate_list_opts).and_return('')
+      allow_any_instance_of(Lita::Handlers::GithubIssues).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubIssues).to receive(:repo?).and_return(true)
+      allow_any_instance_of(Lita::Handlers::GithubIssues).to receive(:validate_list_opts).and_return('')
     end
 
     context 'when all goes well' do
@@ -123,7 +123,9 @@ GrapeDuty/lita-test #84: 'YZYZYZYZ' opened by theckman :: https://github.com/Gra
     end
 
     context 'when there is an option that fails validation' do
-      before { allow(github_issues).to receive(:validate_list_opts).and_return('sadpanda') }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubIssues).to receive(:validate_list_opts).and_return('sadpanda')
+      end
 
       it 'should reply with the response from .validate_list_opts' do
         send_command('gh issues GrapeDuty/lita-test')
@@ -132,7 +134,9 @@ GrapeDuty/lita-test #84: 'YZYZYZYZ' opened by theckman :: https://github.com/Gra
     end
 
     context 'when the repo is not found' do
-      before { allow(github_issues).to receive(:repo?).and_return(false) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubIssues).to receive(:repo?).and_return(false)
+      end
 
       it 'should reply with response indicating repo not found' do
         send_command('gh issues GrapeDuty/lita-test')
@@ -141,7 +145,9 @@ GrapeDuty/lita-test #84: 'YZYZYZYZ' opened by theckman :: https://github.com/Gra
     end
 
     context 'when an option passes validation, but fails from GitHub' do
-      before { allow(@octo_obj).to receive(:list_issues).and_raise(Octokit::UnprocessableEntity.new) }
+      before do
+        allow(@octo_obj).to receive(:list_issues).and_raise(Octokit::UnprocessableEntity.new)
+      end
 
       it 'should reply indicating an issue was hit and include the exception message' do
         send_command('gh issues GrapeDuty/lita-test')
@@ -151,7 +157,9 @@ Octokit::UnprocessableEntity"
     end
 
     context 'when there is a general error when calling GitHub' do
-      before { allow(@octo_obj).to receive(:list_issues).and_raise(StandardError.new) }
+      before do
+        allow(@octo_obj).to receive(:list_issues).and_raise(StandardError.new)
+      end
 
       it 'should reply indicating an issue was hit and include the exception message' do
         send_command('gh issues GrapeDuty/lita-test')

data/spec/unit/lita/handlers/github_org_spec.rb

@@ -135,8 +135,8 @@ describe Lita::Handlers::GithubOrg, lita_handler: true do
       ]
       conf_obj = double('Lita::Configuration', default_org: 'GrapeDuty')
       @octo_obj = double('Octokit::Client', organization_teams: @teams)
-      allow(github_org).to receive(:config).and_return(conf_obj)
-      allow(github_org).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:config).and_return(conf_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:octo).and_return(@octo_obj)
     end
 
     context 'when provided a valid org' do
@@ -169,9 +169,9 @@ Name: HeckmanTest, Slug: heckmantest, ID: 42, Perms: push
       @octo_obj = double('Octokit::Client', create_team: @team)
       @perms = %w(pull push)
       @conf_obj = double('Lita::Config', org_team_add_allowed_perms: @perms)
-      allow(github_org).to receive(:config).and_return(@conf_obj)
-      allow(github_org).to receive(:func_disabled?).and_return(false)
-      allow(github_org).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:config).and_return(@conf_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:octo).and_return(@octo_obj)
     end
 
     context 'when all goes well' do
@@ -184,7 +184,9 @@ Name: HeckmanTest, Slug: heckmantest, ID: 42, Perms: push
     end
 
     context 'when the method is disabled' do
-      before { allow(github_org).to receive(:func_disabled?).and_return(true) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:func_disabled?).and_return(true)
+      end
 
       it 'should return the method disabled error' do
         send_command('gh org team add GrapeDuty name:"HeckmanTest" perms:pull')
@@ -231,10 +233,10 @@ Missing the perms option
     before do
       @team = { name: 'HeckmanTest', id: 42, slug: 'heckmantest', permission: 'pull' }
       @octo_obj = double('Octokit::Client', delete_team: true)
-      allow(github_org).to receive(:config).and_return(@conf_obj)
-      allow(github_org).to receive(:func_disabled?).and_return(false)
-      allow(github_org).to receive(:octo).and_return(@octo_obj)
-      allow(github_org).to receive(:team?).with('42').and_return(@team)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:config).and_return(@conf_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:team?).with('42').and_return(@team)
     end
 
     context 'when all goes well' do
@@ -245,7 +247,9 @@ Missing the perms option
     end
 
     context 'when the method is disabled' do
-      before { allow(github_org).to receive(:func_disabled?).and_return(true) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:func_disabled?).and_return(true)
+      end
 
       it 'should return the method disabled error' do
         send_command('gh org team rm GrapeDuty 42')
@@ -254,7 +258,9 @@ Missing the perms option
     end
 
     context 'when the team does not exist' do
-      before { allow(github_org).to receive(:team?).with('42').and_return(false) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:team?).with('42').and_return(false)
+      end
 
       it 'should respond with the team not found error' do
         send_command('gh org team rm GrapeDuty 42')
@@ -289,9 +295,9 @@ Missing the perms option
       @conf_obj = double('Lita::Config', default_org: 'GrapeDuty')
       allow(@octo_obj).to receive(:user).with(no_args).and_return(@self_user)
       allow(@octo_obj).to receive(:user).with('theckman').and_return(@t_user)
-      allow(github_org).to receive(:func_disabled?).and_return(false)
-      allow(github_org).to receive(:octo).and_return(@octo_obj)
-      allow(github_org).to receive(:cofig).and_return(@conf_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:cofig).and_return(@conf_obj)
     end
 
     context 'when all goes well' do
@@ -302,7 +308,9 @@ Missing the perms option
     end
 
     context 'when the method is disabled' do
-      before { allow(github_org).to receive(:func_disabled?).and_return(true) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:func_disabled?).and_return(true)
+      end
 
       it 'should return the method disabled error' do
         send_command('gh org eject GrapeDuty theckman')
@@ -368,10 +376,10 @@ Missing the perms option
       @conf_obj = double('Lita::Config', default_org: 'GrapeDuty')
       allow(@octo_obj).to receive(:user).with(no_args).and_return(@self_user)
       allow(@octo_obj).to receive(:user).with('theckman').and_return(@t_user)
-      allow(github_org).to receive(:func_disabled?).and_return(false)
-      allow(github_org).to receive(:octo).and_return(@octo_obj)
-      allow(github_org).to receive(:cofig).and_return(@conf_obj)
-      allow(github_org).to receive(:team_id).and_return(42)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:cofig).and_return(@conf_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:team_id).and_return(42)
     end
 
     context 'when all goes well' do
@@ -382,7 +390,9 @@ Missing the perms option
     end
 
     context 'when the method is disabled' do
-      before { allow(github_org).to receive(:func_disabled?).and_return(true) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:func_disabled?).and_return(true)
+      end
 
       it 'should return the method disabled error' do
         send_command('gh org user add GrapeDuty heckmantest theckman')
@@ -448,10 +458,10 @@ Missing the perms option
       @conf_obj = double('Lita::Config', default_org: 'GrapeDuty')
       allow(@octo_obj).to receive(:user).with(no_args).and_return(@self_user)
       allow(@octo_obj).to receive(:user).with('theckman').and_return(@t_user)
-      allow(github_org).to receive(:func_disabled?).and_return(false)
-      allow(github_org).to receive(:octo).and_return(@octo_obj)
-      allow(github_org).to receive(:cofig).and_return(@conf_obj)
-      allow(github_org).to receive(:team_id).and_return(42)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:cofig).and_return(@conf_obj)
+      allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:team_id).and_return(42)
     end
 
     context 'when all goes well' do
@@ -462,7 +472,9 @@ Missing the perms option
     end
 
     context 'when the method is disabled' do
-      before { allow(github_org).to receive(:func_disabled?).and_return(true) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubOrg).to receive(:func_disabled?).and_return(true)
+      end
 
       it 'should return the method disabled error' do
         send_command('gh org user rm GrapeDuty heckmantest theckman')

data/spec/unit/lita/handlers/github_pr_spec.rb

@@ -52,7 +52,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
   describe '.merge_pr' do
     before do
       @octo_obj = double('Octokit::Client', merge_pull_request: :ohai)
-      allow(github_pr).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(@octo_obj)
     end
 
     let(:pr_num) { 42 }
@@ -167,7 +167,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
       @user_obj = { name: 'Tim Heckman' }
       @cs_obj = { state: 'success' }
       @octo_obj = double('Octokit::Client', user: @user_obj, combined_status: @cs_obj)
-      allow(github_pr).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(@octo_obj)
     end
 
     let(:pr_obj) do
@@ -217,7 +217,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
     context 'when user has no name set' do
       before do
         @octo_obj = double('Octokit::Client', user: {}, combined_status: @cs_obj)
-        allow(github_pr).to receive(:octo).and_return(@octo_obj)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(@octo_obj)
       end
 
       it 'should not include the real name parenthesis' do
@@ -269,7 +269,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
     before do
       @user_obj = { name: 'Tim Heckman' }
       @octo_obj = double('Octokit::Client', user: @user_obj)
-      allow(github_pr).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(@octo_obj)
     end
 
     let(:pr_obj) do
@@ -320,7 +320,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
         before do
           @user_obj = {}
           @octo_obj = double('Octokit::Client', user: @user_obj)
-          allow(github_pr).to receive(:octo).and_return(@octo_obj)
+          allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(@octo_obj)
         end
 
         it 'should set the :merged_by key without parenthesis' do
@@ -352,11 +352,11 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
 
   describe '.build_pr_info' do
     before do
-      allow(github_pr).to receive(:build_pr_header!).and_return(nil)
-      allow(github_pr).to receive(:build_pr_commitinfo!).and_return(nil)
-      allow(github_pr).to receive(:build_pr_status!).and_return(nil)
-      allow(github_pr).to receive(:build_pr_merge!).and_return(nil)
-      allow(github_pr).to receive(:build_pr_comments!).and_return(nil)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_header!).and_return(nil)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_commitinfo!).and_return(nil)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_status!).and_return(nil)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_merge!).and_return(nil)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_comments!).and_return(nil)
     end
 
     let(:pr_obj) { :ohai }
@@ -366,27 +366,27 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
     end
 
     it 'should call .build_pr_header!' do
-      expect(github_pr).to receive(:build_pr_header!).with({}, pr_obj).and_return(nil)
+      expect_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_header!).with({}, pr_obj).and_return(nil)
       github_pr.send(:build_pr_info, pr_obj, full_name)
     end
 
     it 'should call .build_pr_commitinfo!' do
-      expect(github_pr).to receive(:build_pr_commitinfo!).with({}, pr_obj).and_return(nil)
+      expect_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_commitinfo!).with({}, pr_obj).and_return(nil)
       github_pr.send(:build_pr_info, pr_obj, full_name)
     end
 
     it 'should call .build_pr_status!' do
-      expect(github_pr).to receive(:build_pr_status!).with({}, pr_obj, full_name).and_return(nil)
+      expect_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_status!).with({}, pr_obj, full_name).and_return(nil)
       github_pr.send(:build_pr_info, pr_obj, full_name)
     end
 
     it 'should call .build_pr_merge!' do
-      expect(github_pr).to receive(:build_pr_merge!).with({}, pr_obj).and_return(nil)
+      expect_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_merge!).with({}, pr_obj).and_return(nil)
       github_pr.send(:build_pr_info, pr_obj, full_name)
     end
 
     it 'should call .build_pr_comments!' do
-      expect(github_pr).to receive(:build_pr_comments!).with({}, pr_obj).and_return(nil)
+      expect_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_comments!).with({}, pr_obj).and_return(nil)
       github_pr.send(:build_pr_info, pr_obj, full_name)
     end
   end
@@ -408,7 +408,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
     before do
       @merge_status = { sha: 'abc456', merged: true, message: 'Pull Request successfully merged' }
       @octo_obj = double('Octokit::Client', merge_pull_request: @merge_status)
-      allow(github_pr).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(@octo_obj)
     end
 
     context 'when all goes well' do
@@ -423,7 +423,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
         @merge_status = { sha: 'abc456', merged: false, message: '*BOOM*' }
         @octo_obj = double('Octokit::Client')
         allow(@octo_obj).to receive(:merge_pull_request).and_raise(StandardError.new)
-        allow(github_pr).to receive(:octo).and_return(@octo_obj)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(@octo_obj)
       end
 
       it 'should return nil' do
@@ -445,8 +445,8 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
           review_comments: 2, comments: 1
         }
         @pr_resp = { fail: false, not_found: false, pr: @pr_info }
-        allow(github_pr).to receive(:pull_request).and_return(@pr_resp)
-        allow(github_pr).to receive(:build_pr_info).and_return(@pr_info)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:pull_request).and_return(@pr_resp)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_info).and_return(@pr_info)
       end
 
       it 'should reply with the expeced output' do
@@ -472,8 +472,8 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
           merged_by: 'theckman (Tim Heckman)', review_comments: 2, comments: 1
         }
         @pr_resp = { fail: false, not_found: false, pr: @pr_info }
-        allow(github_pr).to receive(:pull_request).and_return(@pr_resp)
-        allow(github_pr).to receive(:build_pr_info).and_return(@pr_info)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:pull_request).and_return(@pr_resp)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:build_pr_info).and_return(@pr_info)
       end
 
       it 'should reply with the expeced output' do
@@ -492,7 +492,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
     context 'when the PR was not found' do
       before do
         @pr_resp = { fail: true, not_found: true, pr: @pr_info }
-        allow(github_pr).to receive(:pull_request).and_return(@pr_resp)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:pull_request).and_return(@pr_resp)
       end
 
       it 'should reply with the not found error' do
@@ -508,15 +508,15 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
       @pr_obj =  { head: { ref: 'fix-some-bugs' }, title: 'fix bug' }
       @merge_status = { sha: 'abc456', merged: true, message: 'Pull Request successfully merged' }
       @octo_obj = double('Octokit::Client', pull_request: @pr_obj)
-      allow(github_pr).to receive(:octo).and_return(@octo_obj)
-      allow(github_pr).to receive(:func_disabled?).and_return(false)
-      allow(github_pr).to receive(:config).and_return(@cfg_obj)
-      allow(github_pr).to receive(:merge_pr).and_return(@merge_status)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:config).and_return(@cfg_obj)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:merge_pr).and_return(@merge_status)
     end
 
     context 'when command disabled' do
       before do
-        allow(github_pr).to receive(:func_disabled?).and_return(true)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:func_disabled?).and_return(true)
       end
 
       it 'should no-op and say such' do
@@ -538,7 +538,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
 
     context 'when merging should succeed' do
       it 'should set the right commit message' do
-        expect(github_pr).to receive(:merge_pr).with(
+        expect_any_instance_of(Lita::Handlers::GithubPR).to receive(:merge_pr).with(
           'GrapeDuty', 'lita-test', '42', "Merge pull request #42 from GrapeDuty/fix-some-bugs\n\nfix bug"
         )
         send_command('shipit GrapeDuty/lita-test #42')
@@ -554,7 +554,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
     context 'when merging bombs' do
       before do
         @merge_status = { sha: 'abc456', merged: false, message: '*BOOM*' }
-        allow(github_pr).to receive(:merge_pr).and_return(@merge_status)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:merge_pr).and_return(@merge_status)
       end
 
       it 'should confirm the failure' do
@@ -571,7 +571,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
       before do
         @merge_status = { sha: 'abc456', merged: false, message: '*BOOM*' }
         @octo_obj = double('Octokit::Client', pull_request: @pr_obj)
-        allow(github_pr).to receive(:merge_pr).and_return(nil)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:merge_pr).and_return(nil)
       end
 
       it 'should confirm the failure' do
@@ -589,8 +589,8 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
     before do
       cfg_obj = double('Lita::Configuration')
       octo_obj = double('Octokit::Client', pull_requests: [])
-      allow(github_pr).to receive(:octo).and_return(octo_obj)
-      allow(github_pr).to receive(:config).and_return(cfg_obj)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:config).and_return(cfg_obj)
     end
 
     context 'when there are no pull requests' do
@@ -607,7 +607,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
           { title: 'Test1', number: 42, html_url: 'htmlurl', user: { login: 'theckman' } }
         ]
         octo_obj = double('Octokit::Client', pull_requests: pr)
-        allow(github_pr).to receive(:octo).and_return(octo_obj)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(octo_obj)
       end
 
       it 'should reply with the PRs' do
@@ -643,7 +643,7 @@ describe Lita::Handlers::GithubPR, lita_handler: true do
           { title: 'Test1', number: 42, html_url: 'xxx', user: { login: 'theckman' } }
         ]
         octo_obj = double('Octokit::Client', pull_requests: pr)
-        allow(github_pr).to receive(:octo).and_return(octo_obj)
+        allow_any_instance_of(Lita::Handlers::GithubPR).to receive(:octo).and_return(octo_obj)
       end
 
       it 'should return the list of ten oldest & ten newest' do

data/spec/unit/lita/handlers/github_repo_spec.rb

@@ -128,125 +128,208 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
     end
   end
 
-  describe '.default_team' do
+  describe '.default_teams' do
     before do
       allow(github_repo).to receive(:team_id_by_slug).and_return(88)
     end
 
-    context 'when the default team slug is set' do
+    context 'when default_team_slugs is set' do
       before do
-        cfg_obj = double('Lita::Configuration', default_team_slug: 'heckman')
+        cfg_obj = double('Lita::Configuration', default_team_slugs: ['heckman'])
         allow(github_repo).to receive(:config).and_return(cfg_obj)
       end
 
-      it 'should return the team ID of the slug' do
+      it 'should return an array containing the team ID of the slug' do
         expect(github_repo).to receive(:team_id_by_slug).with('heckman', 'GrapeDuty')
           .and_return(42)
-        expect(github_repo.send(:default_team, github_org)).to eql 42
+        expect(github_repo.send(:default_teams, github_org)).to eql [42]
       end
     end
 
-    context 'when the default slug is not set' do
+    context 'when default_team_slugs is not set' do
       before do
-        cfg_obj = double('Lita::Configuration', default_team_slug: nil)
+        cfg_obj = double('Lita::Configuration', default_team_slugs: nil)
         allow(github_repo).to receive(:config).and_return(cfg_obj)
       end
 
-      it 'should return nil' do
-        expect(github_repo.send(:default_team, github_org)).to be_nil
+      it 'should return [nil]' do
+        expect(github_repo.send(:default_teams, github_org)).to eql [nil]
       end
     end
-  end
 
-  describe '.extrapolate_create_opts' do
-    before do
-      @eco_opts = {}
-      @c_obj = double('Lita::Configuration', default_team_slug: 'h3ckman')
-      allow(github_repo).to receive(:config).and_return(@c_obj)
-      allow(github_repo).to receive(:team_id_by_slug).and_return(42)
-      allow(github_repo).to receive(:should_repo_be_private?).and_return(true)
-    end
+    context 'when default_team_slugs is an empty array' do
+      before do
+        cfg_obj = double('Lita::Configuration', default_team_slugs: [])
+        allow(github_repo).to receive(:config).and_return(cfg_obj)
+      end
 
-    it 'should set the :organization key, :team_id key, and :private key' do
-      h = { organization: github_org, team_id: 42, private: true }
-      expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
+      it 'should return [nil]' do
+        expect(github_repo.send(:default_teams, github_org)).to eql [nil]
+      end
     end
 
-    it 'should set the private key to the return of should_repo_be_private?' do
-      opts = { private: 'test', team_id: 42 }
-      expect(github_repo).to receive(:should_repo_be_private?).with('test').and_return :ohai
-      r = github_repo.send(:extrapolate_create_opts, opts, github_org)
-      expect(r[:private]).to eql :ohai
+    context 'when default_team_slugs is set to an array with multiple elements' do
+      before do
+        cfg_obj = double('Lita::Configuration', default_team_slugs: %w(heckman orwell))
+        allow(github_repo).to receive(:config).and_return(cfg_obj)
+      end
+
+      it 'should return an array containing the corresponding team IDs' do
+        expect(github_repo).to receive(:team_id_by_slug).with('heckman', 'GrapeDuty')
+          .and_return(42)
+        expect(github_repo).to receive(:team_id_by_slug).with('orwell', 'GrapeDuty')
+          .and_return(84)
+        expect(github_repo.send(:default_teams, github_org)).to eql [42, 84]
+      end
     end
+  end
 
-    context 'when there is no :team set' do
-      context 'when default_team returns a team id' do
-        it 'should get the default team_id' do
-          h = { organization: github_org, team_id: 44, private: true }
-          expect(github_repo).to receive(:default_team).with(github_org).and_return(44)
-          expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
-        end
+  describe '.extrapolate_create_opts' do
+    context 'when default_team_slugs is set' do
+      before do
+        @eco_opts = {}
+        @c_obj = double('Lita::Configuration', default_team_slugs: ['h3ckman'])
+        allow(github_repo).to receive(:config).and_return(@c_obj)
+        allow(github_repo).to receive(:team_id_by_slug).and_return(42)
+        allow(github_repo).to receive(:should_repo_be_private?).and_return(true)
       end
 
-      context 'when default_team returns nil' do
-        before do
-          @c_obj = double('Lita::Configuration', default_team_slug: nil)
-          allow(github_repo).to receive(:config).and_return(@c_obj)
-        end
+      it 'should set the :organization key, :team_id key, and :private key' do
+        h = { organization: github_org, team_id: 42, private: true }
+        expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
+      end
 
-        it 'should not set the :team_id key' do
-          h = { organization: github_org, private: true }
-          expect(github_repo).to receive(:default_team).with(github_org).and_return(nil)
-          expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
-        end
+      it 'should set the private key to the return of should_repo_be_private?' do
+        opts = { private: 'test', team_id: 42 }
+        expect(github_repo).to receive(:should_repo_be_private?).with('test').and_return :ohai
+        r = github_repo.send(:extrapolate_create_opts, opts, github_org)
+        expect(r[:private]).to eql :ohai
       end
-    end
 
-    context 'when options contains :team and no :team_id' do
-      context 'when given a valid slug' do
-        before { @eco_opts = { team: 'heckman' } }
+      context 'when there is no :team set' do
+        context 'when default_teams returns an array containing a team id' do
+          it 'should get the default team_id' do
+            h = { organization: github_org, team_id: 44, private: true }
+            expect(github_repo).to receive(:default_teams).with(github_org).and_return([44])
+            expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
+          end
+        end
 
-        it 'should set the :team_id key' do
-          h = { organization: github_org, team_id: 84, private: true }.merge!(@eco_opts)
-          expect(github_repo).to receive(:team_id_by_slug).with('heckman', github_org).and_return(84)
-          expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
+        context 'when default_teams returns [nil]' do
+          before do
+            @c_obj = double('Lita::Configuration', default_team_slugs: nil)
+            allow(github_repo).to receive(:config).and_return(@c_obj)
+          end
+
+          it 'should not set the :team_id key' do
+            h = { organization: github_org, private: true }
+            expect(github_repo).to receive(:default_teams).with(github_org).and_return([nil])
+            expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
+          end
         end
       end
 
-      context 'when given an invalid slug' do
-        context 'when there is a default slug set' do
-          it 'should set the team to the default' do
-            h = { organization: github_org, team_id: 42, private: true }.merge!(@eco_opts)
-            expect(github_repo).to receive(:team_id_by_slug).with('h3ckman', github_org).and_return(42)
+      context 'when options contains :team and no :team_id' do
+        context 'when given a valid slug' do
+          before { @eco_opts = { team: 'heckman' } }
+
+          it 'should set the :team_id key' do
+            h = { organization: github_org, team_id: 84, private: true }.merge!(@eco_opts)
+            expect(github_repo).to receive(:team_id_by_slug).with('heckman', github_org).and_return(84)
             expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
           end
         end
 
-        context 'when there is no default slug set' do
-          before do
-            @eco_opts = { team: 'h3ckman', private: true }
-            c_obj = double('Lita::Configuration', default_team_slug: nil)
-            allow(github_repo).to receive(:config).and_return(c_obj)
+        context 'when given an invalid slug' do
+          context 'when there is a default slug set' do
+            it 'should set the team to the default' do
+              h = { organization: github_org, team_id: 42, private: true }.merge!(@eco_opts)
+              expect(github_repo).to receive(:team_id_by_slug).with('h3ckman', github_org).and_return(42)
+              expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
+            end
           end
 
-          it 'should not set a :team_id' do
-            h = { organization: github_org }.merge!(@eco_opts)
-            expect(github_repo).to receive(:team_id_by_slug).with('h3ckman', github_org)
-              .and_return(nil)
-            expect(github_repo).to receive(:default_team).with(github_org).and_call_original
-            expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
+          context 'when there is no default slug set' do
+            before do
+              @eco_opts = { team: 'h3ckman', private: true }
+              c_obj = double('Lita::Configuration', default_team_slugs: nil)
+              allow(github_repo).to receive(:config).and_return(c_obj)
+            end
+
+            it 'should not set a :team_id' do
+              h = { organization: github_org }.merge!(@eco_opts)
+              expect(github_repo).to receive(:team_id_by_slug).with('h3ckman', github_org)
+                .and_return(nil)
+              expect(github_repo).to receive(:default_teams).with(github_org).and_call_original
+              expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
+            end
           end
         end
       end
+
+      context 'when there is a :team_id key' do
+        before { @eco_opts = { team_id: 44, private: true } }
+
+        it 'should just leave it alone...' do
+          h = { organization: github_org }.merge!(@eco_opts)
+          expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
+        end
+      end
     end
 
-    context 'when there is a :team_id key' do
-      before { @eco_opts = { team_id: 44, private: true } }
+    context 'with an array of default teams' do
+      before do
+        allow(github_repo).to receive(:should_repo_be_private?).and_return(true)
+      end
 
-      it 'should just leave it alone...' do
-        h = { organization: github_org }.merge!(@eco_opts)
-        expect(github_repo).not_to receive(:team_id_by_slug)
-        expect(github_repo.send(:extrapolate_create_opts, @eco_opts, github_org)).to eql h
+      context 'consisting of a nil element' do
+        before do
+          allow(github_repo).to receive(:default_teams).with(github_org).and_return([nil])
+        end
+
+        it 'does not set :team_id' do
+          expect(github_repo.send(:extrapolate_create_opts, { private: true }, github_org)).to eql(organization: github_org, private: true)
+        end
+      end
+
+      context 'consisting of one valid team ID' do
+        before do
+          allow(github_repo).to receive(:default_teams).with(github_org).and_return([42])
+        end
+
+        it 'sets :team_id' do
+          expect(github_repo.send(:extrapolate_create_opts, { private: true }, github_org)).to eql(organization: github_org, team_id: 42, private: true)
+        end
+      end
+
+      context 'consisting of two valid team IDs' do
+        before do
+          allow(github_repo).to receive(:default_teams).with(github_org).and_return([42, 84])
+        end
+
+        it 'sets :team_id and :other_teams' do
+          expect(github_repo.send(:extrapolate_create_opts, { private: true }, github_org)).to eql(organization: github_org, team_id: 42, other_teams: [84], private: true)
+        end
+      end
+
+      context 'consisting of three valid team IDs' do
+        before do
+          allow(github_repo).to receive(:default_teams).with(github_org).and_return([42, 84, 1])
+        end
+
+        it 'sets :team_id and :other_teams' do
+          expect(github_repo.send(:extrapolate_create_opts, { private: true }, github_org)).to eql(organization: github_org, team_id: 42, other_teams: [84, 1], private: true)
+        end
+      end
+
+      context 'consisting of one valid team ID and one invalid team ID' do
+        before do
+          allow(github_repo).to receive(:default_teams).with(github_org).and_return([42, nil])
+        end
+
+        it 'sets :team_id but not :other_teams' do
+          expect(github_repo.send(:extrapolate_create_opts, { private: true }, github_org)).to eql(organization: github_org, team_id: 42, private: true)
+        end
       end
     end
   end
@@ -261,11 +344,20 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
         allow(github_repo).to receive(:repo?).with("#{github_org}/lita-test").and_return(true)
       end
 
-      it 'should confirm succesfful creation' do
+      it 'should confirm successful creation' do
         opts = { private: true, team_id: 42, organization: github_org }
         expect(github_repo.send(:create_repo, github_org, 'lita-test', opts))
           .to eql 'Created GrapeDuty/lita-test: https://github.com/GrapeDuty/lita-test'
       end
+
+      context 'when other teams are given' do
+        it 'should add teams to the repo after creating it' do
+          expect(github_repo).to receive(:add_team_to_repo).with('GrapeDuty/lita-test', 42)
+          expect(github_repo).to receive(:add_team_to_repo).with('GrapeDuty/lita-test', 84)
+          opts = { private: true, team_id: 1, other_teams: [42, 84], organization: github_org }
+          github_repo.send(:create_repo, github_org, 'lita-test', opts)
+        end
+      end
     end
 
     context 'when repo not created' do
@@ -562,10 +654,10 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
       conf_obj = double('Lita::Configuration', default_org: 'GrapeDuty')
       @response = double('Lita::Response', match_data: match_data)
       @octo_obj = double('Octokit::Client', edit_repository: { description: 'oh hello' })
-      allow(github_repo).to receive(:config).and_return(conf_obj)
-      allow(github_repo).to receive(:octo).and_return(@octo_obj)
-      allow(github_repo).to receive(:func_disabled?).and_return(false)
-      allow(github_repo).to receive(:repo?).and_return(true)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:config).and_return(conf_obj)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).and_return(true)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:octo).and_return(@octo_obj)
     end
 
     context 'when valid inputs provided, and all things work out' do
@@ -576,7 +668,9 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
     end
 
     context 'when function disabled' do
-      before { allow(github_repo).to receive(:func_disabled?).and_return(true) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:func_disabled?).and_return(true)
+      end
 
       it 'should return the method disabled error' do
         send_command('gh repo update description lita-test A new description!')
@@ -585,7 +679,9 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
     end
 
     context 'when repo not found' do
-      before { allow(github_repo).to receive(:repo?).and_return(false) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).and_return(false)
+      end
 
       it 'should return the repo not found error' do
         send_command('gh repo update description lita-test A new description!')
@@ -612,10 +708,10 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
       conf_obj = double('Lita::Configuration', default_org: 'GrapeDuty')
       @response = double('Lita::Response', match_data: match_data)
       @octo_obj = double('Octokit::Client', edit_repository: { homepage: 'https://test.it' })
-      allow(github_repo).to receive(:config).and_return(conf_obj)
-      allow(github_repo).to receive(:octo).and_return(@octo_obj)
-      allow(github_repo).to receive(:func_disabled?).and_return(false)
-      allow(github_repo).to receive(:repo?).and_return(true)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:config).and_return(conf_obj)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).and_return(true)
     end
 
     context 'when valid inputs provided, and all things work out' do
@@ -626,7 +722,9 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
     end
 
     context 'when function disabled' do
-      before { allow(github_repo).to receive(:func_disabled?).and_return(true) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:func_disabled?).and_return(true)
+      end
 
       it 'should return the method disabled error' do
         send_command('gh repo update homepage lita-test https://test.it')
@@ -635,7 +733,9 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
     end
 
     context 'when repo not found' do
-      before { allow(github_repo).to receive(:repo?).and_return(false) }
+      before do
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).and_return(false)
+      end
 
       it 'should return the repo not found error' do
         send_command('gh repo update homepage lita-test https://test.it')
@@ -685,7 +785,7 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
       }
       pr = [nil, nil, nil, nil, nil]
       @octo_obj = double('Octokit::Client', repository: repo, pull_requests: pr)
-      allow(github_repo).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:octo).and_return(@octo_obj)
     end
 
     it 'should return some repo info' do
@@ -699,9 +799,9 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
 
   describe '.repo_delete' do
     before do
-      allow(github_repo).to receive(:func_disabled?).and_return(false)
-      allow(github_repo).to receive(:delete_repo).and_return('hello there')
-      allow(github_repo).to receive(:repo?).with("#{github_org}/lita-test").and_return(true)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:delete_repo).and_return('hello there')
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).with("#{github_org}/lita-test").and_return(true)
     end
 
     it 'reply with the return from delete_repo()' do
@@ -711,7 +811,7 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
 
     context 'when command disabled' do
       before do
-        allow(github_repo).to receive(:func_disabled?).and_return(true)
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:func_disabled?).and_return(true)
       end
 
       it 'should no-op and say such if the command is disabled' do
@@ -722,7 +822,7 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
 
     context 'when repo not found' do
       before do
-        allow(github_repo).to receive(:repo?).with("#{github_org}/lita-test").and_return(false)
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).with("#{github_org}/lita-test").and_return(false)
       end
 
       it 'should no-op informing you that the repo is not there' do
@@ -735,15 +835,15 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
   describe '.repo_create' do
     before do
       @opts = { private: true, team_id: 42, organization: github_org }
-      allow(github_repo).to receive(:func_disabled?).and_return(false)
-      allow(github_repo).to receive(:repo?).with("#{github_org}/lita-test").and_return(false)
-      allow(github_repo).to receive(:extrapolate_create_opts).and_return(@opts)
-      allow(github_repo).to receive(:create_repo).and_return('hello from PAX prime!')
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).with("#{github_org}/lita-test").and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:extrapolate_create_opts).and_return(@opts)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:create_repo).and_return('hello from PAX prime!')
     end
 
     context 'when command disabled' do
       before do
-        allow(github_repo).to receive(:func_disabled?).and_return(true)
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:func_disabled?).and_return(true)
       end
 
       it 'should no-op and say such if the command is disabled' do
@@ -754,7 +854,7 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
 
     context 'when repo already exists' do
       before do
-        allow(github_repo).to receive(:repo?).with("#{github_org}/lita-test").and_return(true)
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).with("#{github_org}/lita-test").and_return(true)
       end
 
       it 'should tell you it already exists' do
@@ -765,11 +865,11 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
 
     context 'when repo does not exist' do
       before do
-        allow(github_repo).to receive(:repo?).with("#{github_org}/lita-test").and_return(false)
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).with("#{github_org}/lita-test").and_return(false)
       end
 
       it 'should reply with the return of create_repo()' do
-        expect(github_repo).to receive(:extrapolate_create_opts).and_return(@opts)
+        expect_any_instance_of(Lita::Handlers::GithubRepo).to receive(:extrapolate_create_opts).and_return(@opts)
         send_command("gh repo create #{github_org}/lita-test")
         expect(replies.last).to eql 'hello from PAX prime!'
       end
@@ -778,9 +878,9 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
 
   describe '.repo_rename' do
     before do
-      allow(github_repo).to receive(:func_disabled?).and_return(false)
-      allow(github_repo).to receive(:rename_repo).and_return('hello there')
-      allow(github_repo).to receive(:repo?).with("#{github_org}/lita-test").and_return(true)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:func_disabled?).and_return(false)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:rename_repo).and_return('hello there')
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).with("#{github_org}/lita-test").and_return(true)
     end
 
     it 'reply with the return from rename_repo()' do
@@ -790,7 +890,7 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
 
     context 'when command disabled' do
       before do
-        allow(github_repo).to receive(:func_disabled?).and_return(true)
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:func_disabled?).and_return(true)
       end
 
       it 'should no-op and say such if the command is disabled' do
@@ -801,7 +901,7 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
 
     context 'when repo not found' do
       before do
-        allow(github_repo).to receive(:repo?).with("#{github_org}/lita-test").and_return(false)
+        allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo?).with("#{github_org}/lita-test").and_return(false)
       end
 
       it 'should no-op informing you that the repo is not there' do
@@ -818,7 +918,7 @@ describe Lita::Handlers::GithubRepo, lita_handler: true do
         { name: 'Everyone', slug: 'everyone', id: 42, permission: 'push' }
       ]
       @octo_obj = double('Octokit::Client', repository_teams: @teams)
-      allow(github_repo).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:octo).and_return(@octo_obj)
     end
 
     context 'when it finds a repo' do
@@ -853,11 +953,11 @@ Name: Interns, Slug: interns, ID: 84, Perms: pull
 
   describe '.repo_team_router' do
     before do
-      allow(github_repo).to receive(:repo_team_add).with(an_instance_of(Lita::Response)).and_return('ohai')
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo_team_add).with(an_instance_of(Lita::Response)).and_return('ohai')
     end
 
     it 'should call the method based on action and respond with its return' do
-      expect(github_repo).to receive(:repo_team_add).with(an_instance_of(Lita::Response)).and_return('ohai')
+      expect_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo_team_add).with(an_instance_of(Lita::Response)).and_return('ohai')
       send_command("gh repo team add 42 #{github_org}/lita-test")
       expect(replies.last).to eql 'ohai'
     end
@@ -865,11 +965,11 @@ Name: Interns, Slug: interns, ID: 84, Perms: pull
 
   describe '.repo_update_router' do
     before do
-      allow(github_repo).to receive(:repo_update_description).with(an_instance_of(Lita::Response)).and_return('ohai')
+      allow_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo_update_description).with(an_instance_of(Lita::Response)).and_return('ohai')
     end
 
     it 'should call the method based on the action and respond with its return' do
-      expect(github_repo).to receive(:repo_update_description).with(an_instance_of(Lita::Response)).and_return('ohai')
+      expect_any_instance_of(Lita::Handlers::GithubRepo).to receive(:repo_update_description).with(an_instance_of(Lita::Response)).and_return('ohai')
       send_command("gh repo update description #{github_org}/lita-test Something funky here")
       expect(replies.last).to eql 'ohai'
     end

data/spec/unit/lita/handlers/github_spec.rb

@@ -300,7 +300,7 @@ Following: 20, Followers: 10, Joined: 2011-05-14 04:16:33 UTC'
     before do
       @secret = 'GZSDEMLDMY3TQYLG'
       conf_obj = double('Lita::Configuration', totp_secret: @secret)
-      allow(github).to receive(:config).and_return(conf_obj)
+      allow_any_instance_of(Lita::Handlers::Github).to receive(:config).and_return(conf_obj)
     end
 
     context 'when token is set' do
@@ -314,7 +314,7 @@ Following: 20, Followers: 10, Joined: 2011-05-14 04:16:33 UTC'
     context 'when token is not set' do
       before do
         conf_obj = double('Lita::Configuration', totp_secret: nil)
-        allow(github).to receive(:config).and_return(conf_obj)
+        allow_any_instance_of(Lita::Handlers::Github).to receive(:config).and_return(conf_obj)
       end
 
       it 'should return the error message' do
@@ -344,15 +344,15 @@ Following: 20, Followers: 10, Joined: 2011-05-14 04:16:33 UTC'
       }
       @orgs = [{ login: 'PagerDuty' }, { login: 'GrapeDuty' }]
       @octo_obj = double('Octokit::Client', user: @user_obj, organizations: @orgs)
-      allow(github).to receive(:octo).and_return(@octo_obj)
-      allow(github).to receive(:whois_reply).and_return('StubbedResponse')
+      allow_any_instance_of(Lita::Handlers::Github).to receive(:octo).and_return(@octo_obj)
+      allow_any_instance_of(Lita::Handlers::Github).to receive(:whois_reply).and_return('StubbedResponse')
     end
 
     context 'when all goes well' do
       it 'should return the response from whois_reply' do
         expect(@octo_obj).to receive(:user).with('theckman').and_return(@user_obj)
         expect(@octo_obj).to receive(:organizations).with('theckman').and_return(@orgs)
-        expect(github).to receive(:whois_reply).with(@user_obj, %w(PagerDuty GrapeDuty)).and_return('StubbedResponse')
+        allow_any_instance_of(Lita::Handlers::Github).to receive(:whois_reply).with(@user_obj, %w(PagerDuty GrapeDuty)).and_return('StubbedResponse')
         send_command('gh whois theckman')
         expect(replies.last).to eql 'StubbedResponse'
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-github
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Tim Heckman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-29 00:00:00.000000000 Z
+date: 2015-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -257,7 +257,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: GitHub repo/org management in Lita; handler not ready for production