git_reflow 0.7.5 → 0.8.0

data/spec/lib/git_reflow/git_helpers_spec.rb

@@ -22,32 +22,32 @@ describe GitReflow::GitHelpers do
   describe ".remote_user" do
     subject { Gitacular.remote_user }
 
-    it { should == 'reenhanced.spectacular' }
+    it { is_expected.to eq('reenhanced.spectacular') }
 
     context "remote origin url isn't set" do
       let(:origin_url) { nil }
-      it { should == '' }
+      it { is_expected.to eq('') }
     end
 
     context "remote origin uses HTTP" do
       let(:origin_url) { 'https://github.com/reenhanced.spectacular/this-is-the.shit.git' }
-      it               { should == 'reenhanced.spectacular' }
+      it               { is_expected.to eq('reenhanced.spectacular') }
     end
   end
 
   describe ".remote_repo_name" do
     subject { Gitacular.remote_repo_name }
 
-    it { should == 'this-is-the.shit' }
+    it { is_expected.to eq('this-is-the.shit') }
 
     context "remote origin url isn't set" do
       let(:origin_url) { nil }
-      it { should == '' }
+      it { is_expected.to eq('') }
     end
 
     context "remote origin uses HTTP" do
       let(:origin_url) { 'https://github.com/reenhanced.spectacular/this-is-the.shit.git' }
-      it               { should == 'this-is-the.shit' }
+      it               { is_expected.to eq('this-is-the.shit') }
     end
   end
 
@@ -63,7 +63,7 @@ describe GitReflow::GitHelpers do
 
   describe ".push_current_branch" do
     subject { Gitacular.push_current_branch }
-    before  { Gitacular.stub(:current_branch).and_return('bingo') }
+    before  { allow(Gitacular).to receive(:current_branch).and_return('bingo') }
     it      { expect{ subject }.to have_run_command "git push origin bingo" }
   end
 
@@ -76,7 +76,7 @@ describe GitReflow::GitHelpers do
     let(:current_branch)     { 'bananas' }
     let(:destination_branch) { 'monkey-business' }
 
-    before  { Gitacular.stub(:current_branch).and_return(current_branch) }
+    before  { allow(Gitacular).to receive(:current_branch).and_return(current_branch) }
     subject { Gitacular.update_destination(destination_branch) }
 
     it "updates the destination branch with the latest code from the remote repo" do
@@ -90,7 +90,7 @@ describe GitReflow::GitHelpers do
 
   describe ".update_current_branch" do
     subject { Gitacular.update_current_branch }
-    before  { Gitacular.stub(:current_branch).and_return('new-feature') }
+    before  { allow(Gitacular).to receive(:current_branch).and_return('new-feature') }
 
     it "updates the remote changes and pushes any local changes" do
       expect { subject }.to have_run_commands_in_order [
@@ -100,64 +100,20 @@ describe GitReflow::GitHelpers do
     end
   end
 
-  describe ".merge_feature_branch(options)" do
-    let(:destination_branch) { 'monkey-business' }
-    let(:feature_branch)     { 'bananas' }
-    let(:merge_options)      { {} }
-
-    subject { Gitacular.merge_feature_branch(feature_branch, merge_options) }
+  describe ".update_feature_branch" do
+    options = {base: "base", remote: "remote"}
+    subject { Gitacular.update_feature_branch(options) }
+    before  { allow(Gitacular).to receive(:current_branch).and_return('feature') }
 
-    it 'checks out master as the default destination branch and squash merges the feature branch' do
+    it "calls the correct methods" do
       expect { subject }.to have_run_commands_in_order [
-        'git checkout master',
-        "git merge --squash #{feature_branch}"
+        "git checkout base",
+        "git pull remote base",
+        "git checkout feature",
+        "git pull origin feature",
+        "git merge base"
       ]
     end
-
-    context "providing a destination branch" do
-      let(:merge_options) {{ destination_branch: destination_branch }}
-      it { expect{ subject }.to have_run_command "git checkout #{destination_branch}" }
-    end
-
-    context "with a message" do
-      let(:merge_options) {{ message: "don't throw doo doo" }}
-      it "appends the message to the squashed commit message" do
-        Gitacular.should_receive(:append_to_squashed_commit_message).with("don't throw doo doo")
-        subject
-      end
-
-      context 'and a pull reuqest number' do
-        before { merge_options.merge!(pull_request_number: 3) }
-        it "appends the message to the squashed commit message" do
-          Gitacular.should_receive(:append_to_squashed_commit_message).with("don't throw doo doo\nCloses #3\n")
-          subject
-        end
-      end
-    end
-
-    context "with a pull request number" do
-      let(:merge_options) {{ pull_request_number: 3 }}
-      it "appends the message to the squashed commit message" do
-        Gitacular.should_receive(:append_to_squashed_commit_message).with("\nCloses #3\n")
-        subject
-      end
-    end
-
-    context "with one LGTM author" do
-      let(:merge_options) {{ lgtm_authors: 'codenamev' }}
-      it "appends the message to the squashed commit message" do
-        Gitacular.should_receive(:append_to_squashed_commit_message).with("\nLGTM given by: @#{merge_options[:lgtm_authors]}\n")
-        subject
-      end
-    end
-
-    context "with LGTM authors" do
-      let(:merge_options) {{ lgtm_authors: ['codenamev', 'nhance'] }}
-      it "appends the message to the squashed commit message" do
-        Gitacular.should_receive(:append_to_squashed_commit_message).with("\nLGTM given by: @#{merge_options[:lgtm_authors].join(', @')}\n")
-        subject
-      end
-    end
   end
 
   describe ".append_to_squashed_commit_message(message)" do

data/spec/lib/git_reflow/git_server_spec.rb

@@ -6,7 +6,7 @@ describe GitReflow::GitServer do
   subject { GitReflow::GitServer.connect connection_options }
 
   before do
-    GitReflow::GitServer::GitHub.stub(:new)
+    allow(GitReflow::GitServer::GitHub).to receive(:new)
 
     module GitReflow::GitServer
       class DummyHub < Base
@@ -27,8 +27,8 @@ describe GitReflow::GitServer do
   describe '.connect(options)' do
     it 'initializes a new GitHub server provider by default' do
       stubbed_github = Class.new
-      stubbed_github.stub(:authenticate)
-      GitReflow::GitServer::GitHub.should_receive(:new).and_return(stubbed_github)
+      allow(stubbed_github).to receive(:authenticate)
+      expect(GitReflow::GitServer::GitHub).to receive(:new).and_return(stubbed_github)
       subject
     end
 
@@ -38,39 +38,39 @@ describe GitReflow::GitServer do
 
       it 'initializes any server provider that has been implemented' do
         dummy_hub = GitReflow::GitServer::DummyHub.new({})
-        GitReflow::GitServer::DummyHub.should_receive(:new).with(expected_server_options).and_return(dummy_hub)
-        subject.should == dummy_hub
-        $output.should_not include 'GitServer not setup for: DummyHub'
+        expect(GitReflow::GitServer::DummyHub).to receive(:new).with(expected_server_options).and_return(dummy_hub)
+        expect(subject).to eq(dummy_hub)
+        expect($says).not_to include 'GitServer not setup for: DummyHub'
       end
     end
 
     context 'provider not yet implemented' do
       let(:connection_options) {{ provider: 'GitLab' }}
-      it { expect{ subject }.to have_output "Error connecting to GitLab: GitServer not setup for \"GitLab\"" }
+      it { expect{ subject }.to have_said "Error connecting to GitLab: GitServer not setup for \"GitLab\"", :error }
     end
   end
 
   describe '.current_provider' do
     subject { GitReflow::GitServer.current_provider }
 
-    before { GitReflow::Config.stub(:get).with('reflow.git-server', local: true).and_return(nil) }
+    before { allow(GitReflow::Config).to receive(:get).with('reflow.git-server', local: true).and_return(nil) }
 
     context 'Reflow setup to use GitHub' do
-      before { GitReflow::Config.stub(:get).with('reflow.git-server').and_return('GitHub') }
-      it     { should == GitReflow::GitServer::GitHub }
+      before { allow(GitReflow::Config).to receive(:get).with('reflow.git-server').and_return('GitHub') }
+      it     { is_expected.to eq(GitReflow::GitServer::GitHub) }
     end
 
     context 'Reflow has not yet been setup' do
-      before { GitReflow::Config.stub(:get).with('reflow.git-server').and_return('') }
-      it     { should be_nil }
-      it     { expect{ subject }.to have_output "[notice] Reflow hasn't been setup yet.  Run 'git reflow setup' to continue" }
+      before { allow(GitReflow::Config).to receive(:get).with('reflow.git-server').and_return('') }
+      it     { is_expected.to be_nil }
+      it     { expect{ subject }.to have_said "Reflow hasn't been setup yet.  Run 'git reflow setup' to continue", :notice }
     end
 
     context 'an unknown server provider is stored in the git config' do
-      before { GitReflow::Config.stub(:get).with('reflow.git-server').and_return('GittyUp') }
+      before { allow(GitReflow::Config).to receive(:get).with('reflow.git-server').and_return('GittyUp') }
 
-      it { should be_nil }
-      it { expect{ subject }.to have_output "GitServer not setup for \"GittyUp\"" }
+      it { is_expected.to be_nil }
+      it { expect{ subject }.to have_said "GitServer not setup for \"GittyUp\"", :error }
     end
   end
 
@@ -78,24 +78,24 @@ describe GitReflow::GitServer do
     subject { GitReflow::GitServer.connection }
 
     before do
-      GitReflow::Config.stub(:get).with('reflow.git-server', local: true).and_return(nil)
-      GitReflow::Config.stub(:get).with('reflow.git-server').and_return(nil)
+      allow(GitReflow::Config).to receive(:get).with('reflow.git-server', local: true).and_return(nil)
+      allow(GitReflow::Config).to receive(:get).with('reflow.git-server').and_return(nil)
     end
 
-    it { should be_nil }
+    it { is_expected.to be_nil }
 
     context "with a valid provider" do
-      before { GitReflow::Config.stub(:get).with('reflow.git-server').and_return('GitHub') }
+      before { allow(GitReflow::Config).to receive(:get).with('reflow.git-server').and_return('GitHub') }
       it 'calls connection on the provider' do
-        GitReflow::GitServer::GitHub.should_receive(:connection)
+        expect(GitReflow::GitServer::GitHub).to receive(:connection)
         subject
       end
     end
 
     context "with an invalid provider" do
-      before { GitReflow::Config.stub(:get).with('reflow.git-server').and_return('GittyUp') }
-      it     { should be_nil }
-      it     { expect{ subject }.to have_output "GitServer not setup for \"GittyUp\"" }
+      before { allow(GitReflow::Config).to receive(:get).with('reflow.git-server').and_return('GittyUp') }
+      it     { is_expected.to be_nil }
+      it     { expect{ subject }.to have_said "GitServer not setup for \"GittyUp\"", :error }
     end
   end
 end

data/spec/lib/git_server/bit_bucket_spec.rb

@@ -11,7 +11,7 @@ describe GitReflow::GitServer::BitBucket do
   let(:remote_url)   { "git@bitbucket.org:#{user}/#{repo}.git" }
 
   before do
-    HighLine.any_instance.stub(:ask) do |terminal, question|
+    allow_any_instance_of(HighLine).to receive(:ask) do |terminal, question|
       values = {
         "Please enter your BitBucket username: " => user
       }
@@ -25,7 +25,7 @@ describe GitReflow::GitServer::BitBucket do
     subject { GitReflow::GitServer::BitBucket.new({}) }
 
     it 'sets the reflow git server provider to BitBucket in the git config' do
-      GitReflow::Config.should_receive(:set).once.with('reflow.git-server', 'BitBucket', local: false)
+      expect(GitReflow::Config).to receive(:set).once.with('reflow.git-server', 'BitBucket', local: false)
       subject
     end
 
@@ -33,7 +33,7 @@ describe GitReflow::GitServer::BitBucket do
       subject { GitReflow::GitServer::BitBucket.new(project_only: true) }
 
       it 'sets the enterprise site and api as the site and api endpoints for the BitBucket provider in the git config' do
-        GitReflow::Config.should_receive(:set).once.with('reflow.git-server', 'BitBucket', local: true)
+        expect(GitReflow::Config).to receive(:set).once.with('reflow.git-server', 'BitBucket', local: true)
         subject
       end
     end
@@ -52,27 +52,27 @@ describe GitReflow::GitServer::BitBucket do
         allow(GitReflow::Config).to receive(:get).with('bitbucket.user', local: false).and_return(user)
         allow(GitReflow::Config).to receive(:get).with('bitbucket.api-key', reload: true, local: false).and_return(api_key)
         allow(GitReflow::Config).to receive(:get).with('reflow.local-projects', all: true).and_return('')
-        expect { subject }.to have_output "\nYour BitBucket account was already setup with:"
-        expect { subject }.to have_output "\tUser Name: #{user}"
+        expect { subject }.to have_said "\nYour BitBucket account was already setup with:"
+        expect { subject }.to have_said "\tUser Name: #{user}"
       end
     end
 
     context 'not yet authenticated' do
       context 'with valid BitBucket credentials' do
         before do
-          GitReflow::Config.stub(:get).and_return('')
-          GitReflow::Config.stub(:set)
-          GitReflow::Config.stub(:set).with('bitbucket.api-key', reload: true).and_return(api_key)
+          allow(GitReflow::Config).to receive(:get).and_return('')
+          allow(GitReflow::Config).to receive(:set)
+          allow(GitReflow::Config).to receive(:set).with('bitbucket.api-key', reload: true).and_return(api_key)
           allow(GitReflow::Config).to receive(:get).with('bitbucket.api-key', reload: true).and_return('')
           allow(GitReflow::Config).to receive(:get).with('remote.origin.url').and_return(remote_url)
           allow(GitReflow::Config).to receive(:get).with('reflow.local-projects').and_return('')
-          bitbucket.stub(:connection).and_return double(repos: double(all: []))
+          allow(bitbucket).to receive(:connection).and_return double(repos: double(all: []))
         end
 
         it "prompts me to setup an API key" do
-          expect { subject }.to have_output "\nIn order to connect your BitBucket account,"
-          expect { subject }.to have_output "you'll need to generate an API key for your team"
-          expect { subject }.to have_output "Visit https://bitbucket.org/account/user/reenhanced/api-key/, to generate it\n"
+          expect { subject }.to have_said "\nIn order to connect your BitBucket account,"
+          expect { subject }.to have_said "you'll need to generate an API key for your team"
+          expect { subject }.to have_said "Visit https://bitbucket.org/account/user/reenhanced/api-key/, to generate it\n"
         end
       end
     end

data/spec/lib/git_server/git_hub/pull_request_spec.rb

@@ -16,6 +16,8 @@ describe GitReflow::GitServer::GitHub::PullRequest do
   let(:existing_pull_requests)  { Fixture.new('pull_requests/pull_requests.json').to_json_hashie }
   let(:existing_pull_commits)   { Fixture.new('pull_requests/commits.json').to_json_hashie }
   let(:comment_author)          { 'octocat' }
+  let(:feature_branch_name)     { existing_pull_request.head.label[/[^:]+$/] }
+  let(:base_branch_name)        { existing_pull_request.base.label[/[^:]+$/] }
   let(:existing_pull_comments)  {
     Fixture.new('pull_requests/comments.json.erb',
                 repo_owner: user,
@@ -40,8 +42,8 @@ describe GitReflow::GitServer::GitHub::PullRequest do
       "Please enter your Enterprise API endpoint (e.g. https://github.company.com/api/v3):" => enterprise_api
     })
 
-    github.class.stub(:remote_user).and_return(user)
-    github.class.stub(:remote_repo_name).and_return(repo)
+    allow(github.class).to receive(:remote_user).and_return(user)
+    allow(github.class).to receive(:remote_repo_name).and_return(repo)
     allow(GitReflow::GitServer::PullRequest).to receive(:approval_regex).and_return(/(?i-mx:lgtm|looks good to me|:\+1:|:thumbsup:|:shipit:)/)
   end
 
@@ -49,8 +51,8 @@ describe GitReflow::GitServer::GitHub::PullRequest do
     specify { expect(subject.number).to eql(existing_pull_request.number) }
     specify { expect(subject.description).to eql(existing_pull_request.body) }
     specify { expect(subject.html_url).to eql(existing_pull_request.html_url) }
-    specify { expect(subject.feature_branch_name).to eql(existing_pull_request.head.label) }
-    specify { expect(subject.base_branch_name).to eql(existing_pull_request.base.label) }
+    specify { expect(subject.feature_branch_name).to eql(feature_branch_name) }
+    specify { expect(subject.base_branch_name).to eql(base_branch_name) }
     specify { expect(subject.build_status).to eql('success') }
     specify { expect(subject.source_object).to eql(existing_pull_request) }
   end
@@ -85,7 +87,7 @@ describe GitReflow::GitServer::GitHub::PullRequest do
     context "Testing Nil Comments" do
       before do
         stub_request(:get, "https://api.github.com/repos/reenhanced/repo/pulls/2/comments?access_token=a1b2c3d4e5f6g7h8i9j0").
-         with(:headers => {'Accept'=>'application/vnd.github.v3+json,application/vnd.github.beta+json;q=0.5,application/json;q=0.1', 'Accept-Charset'=>'utf-8', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Authorization'=>'token a1b2c3d4e5f6g7h8i9j0', 'User-Agent'=>'Github API Ruby Gem 0.12.4'}).
+         with(:headers => {'Accept'=>'application/vnd.github.v3+json,application/vnd.github.beta+json;q=0.5,application/json;q=0.1', 'Accept-Charset'=>'utf-8', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Authorization'=>'token a1b2c3d4e5f6g7h8i9j0', 'User-Agent'=>'Github API Ruby Gem 0.14.0'}).
          to_return(:status => 200, :body => "", :headers => {})
 
         FakeGitHub.new(

data/spec/lib/git_server/git_hub_spec.rb

@@ -16,7 +16,7 @@ describe GitReflow::GitServer::GitHub do
   let(:existing_pull_requests) { Fixture.new('pull_requests/pull_requests.json').to_json_hashie }
 
   before do
-    HighLine.any_instance.stub(:ask) do |terminal, question|
+    allow_any_instance_of(HighLine).to receive(:ask) do |terminal, question|
       values = {
         "Please enter your GitHub username: "                                                 => user,
         "Please enter your GitHub password (we do NOT store this): "                          => password,
@@ -28,17 +28,17 @@ describe GitReflow::GitServer::GitHub do
      return_value
     end
 
-    github.class.stub(:remote_user).and_return(user)
-    github.class.stub(:remote_repo_name).and_return(repo)
+    allow(github.class).to receive(:remote_user).and_return(user)
+    allow(github.class).to receive(:remote_repo_name).and_return(repo)
   end
 
   describe '#initialize(options)' do
     subject { GitReflow::GitServer::GitHub.new({}) }
 
     it 'sets the reflow git server provider to GitHub in the git config' do
-      GitReflow::Config.should_receive(:set).once.with('github.site', github_site, local: false)
-      GitReflow::Config.should_receive(:set).once.with('github.endpoint', github_api_endpoint, local: false)
-      GitReflow::Config.should_receive(:set).once.with('reflow.git-server', 'GitHub', local: false)
+      expect(GitReflow::Config).to receive(:set).once.with('github.site', github_site, local: false)
+      expect(GitReflow::Config).to receive(:set).once.with('github.endpoint', github_api_endpoint, local: false)
+      expect(GitReflow::Config).to receive(:set).once.with('reflow.git-server', 'GitHub', local: false)
       subject
     end
 
@@ -46,9 +46,9 @@ describe GitReflow::GitServer::GitHub do
       subject { GitReflow::GitServer::GitHub.new(enterprise: true) }
 
       it 'sets the enterprise site and api as the site and api endpoints for the GitHub provider in the git config' do
-        GitReflow::Config.should_receive(:set).once.with('github.site', enterprise_site, local: false)
-        GitReflow::Config.should_receive(:set).once.with('github.endpoint', enterprise_api, local: false)
-        GitReflow::Config.should_receive(:set).once.with('reflow.git-server', 'GitHub', local: false)
+        expect(GitReflow::Config).to receive(:set).once.with('github.site', enterprise_site, local: false)
+        expect(GitReflow::Config).to receive(:set).once.with('github.endpoint', enterprise_api, local: false)
+        expect(GitReflow::Config).to receive(:set).once.with('reflow.git-server', 'GitHub', local: false)
         subject
       end
 
@@ -58,13 +58,13 @@ describe GitReflow::GitServer::GitHub do
       subject { GitReflow::GitServer::GitHub.new(project_only: true) }
 
       before do
-        GitReflow::Config.should_receive(:get).twice.with('reflow.local-projects', all: true).and_return("#{user}/#{repo}")
+        expect(GitReflow::Config).to receive(:get).twice.with('reflow.local-projects', all: true).and_return("#{user}/#{repo}")
       end
 
       it 'sets the enterprise site and api as the site and api endpoints for the GitHub provider in the git config' do
-        GitReflow::Config.should_receive(:set).once.with('github.site', github_site, local: true).and_call_original
-        GitReflow::Config.should_receive(:set).once.with('github.endpoint', github_api_endpoint, local: true)
-        GitReflow::Config.should_receive(:set).once.with('reflow.git-server', 'GitHub', local: true)
+        expect(GitReflow::Config).to receive(:set).once.with('github.site', github_site, local: true).and_call_original
+        expect(GitReflow::Config).to receive(:set).once.with('github.endpoint', github_api_endpoint, local: true)
+        expect(GitReflow::Config).to receive(:set).once.with('reflow.git-server', 'GitHub', local: true)
         subject
       end
     end
@@ -73,32 +73,32 @@ describe GitReflow::GitServer::GitHub do
 
   describe '#authenticate' do
     let(:github)                { GitReflow::GitServer::GitHub.new({}) }
-    let!(:github_api)           { Github.new }
+    let!(:github_api)           { Github::Client.new }
     let(:github_authorizations) { Github::Client::Authorizations.new }
     subject                     { github.authenticate }
 
     before  do
-      GitReflow::GitServer::GitHub.stub(:user).and_return('reenhanced')
-      github_api.stub(:oauth).and_return(github_authorizations)
-      github_api.stub_chain(:oauth, :all).and_return([])
-      github.stub(:run).with('hostname', loud: false).and_return(hostname)
+      allow(GitReflow::GitServer::GitHub).to receive(:user).and_return('reenhanced')
+      allow(github_api).to receive(:oauth).and_return(github_authorizations)
+      allow(github_api).to receive_message_chain(:oauth, :all).and_return([])
+      allow(github).to receive(:run).with('hostname', loud: false).and_return(hostname)
     end
 
     context 'not yet authenticated' do
       context 'with valid GitHub credentials' do
 
         before do
-          Github.stub(:new).and_return(github_api)
-          github_authorizations.stub(:authenticated?).and_return(true)
-          github_api.oauth.stub(:create).with({ scopes: ['repo'], note: "git-reflow (#{hostname})" }).and_return(oauth_token_hash)
+          allow(Github::Client).to receive(:new).and_return(github_api)
+          allow(github_authorizations).to receive(:authenticated?).and_return(true)
+          allow(github_api.oauth).to receive(:create).with({ scopes: ['repo'], note: "git-reflow (#{hostname})" }).and_return(oauth_token_hash)
         end
 
         it "notifies the user of successful setup" do
-          expect { subject }.to have_output "\nYour GitHub account was successfully setup!"
+          expect { subject }.to have_said "Your GitHub account was successfully setup!", :success
         end
 
         it "creates a new GitHub oauth token" do
-          github_api.oauth.should_receive(:create).and_return(oauth_token_hash)
+          expect(github_api.oauth).to receive(:create).and_return(oauth_token_hash)
           subject
         end
 
@@ -133,7 +133,7 @@ describe GitReflow::GitServer::GitHub do
 
         context "use GitHub enterprise account" do
           let(:github) { GitReflow::GitServer::GitHub.new(enterprise: true) }
-          before { GitReflow::GitServer::GitHub.stub(:@using_enterprise).and_return(true) }
+          before { allow(GitReflow::GitServer::GitHub).to receive(:@using_enterprise).and_return(true) }
           it "creates git config keys for github connections" do
             expect{ subject }.to have_run_command_silently "git config -f #{GitReflow::Config::CONFIG_FILE_PATH} --replace-all github.site \"#{enterprise_site}\""
             expect{ subject }.to have_run_command_silently "git config -f #{GitReflow::Config::CONFIG_FILE_PATH} --replace-all github.endpoint \"#{enterprise_api}\""
@@ -152,11 +152,11 @@ describe GitReflow::GitServer::GitHub do
         }}
 
         before do
-          Github.should_receive(:new).and_raise Github::Error::Unauthorized.new(unauthorized_error_response)
+          allow(Github::Client).to receive(:new).and_raise Github::Error::Unauthorized.new(unauthorized_error_response)
         end
 
         it "notifies user of invalid login details" do
-          expect { subject }.to have_output "\nGithub Authentication Error: #{Github::Error::Unauthorized.new(unauthorized_error_response).inspect}"
+          expect { subject }.to have_said "Github Authentication Error: #{Github::Error::Unauthorized.new(unauthorized_error_response).inspect}", :error
         end
       end
     end
@@ -170,7 +170,7 @@ describe GitReflow::GitServer::GitHub do
     subject { github.create_pull_request({ title: title, body: body, base: 'master' }) }
 
     before do
-      github.class.stub(:current_branch).and_return(current_branch)
+      allow(github.class).to receive(:current_branch).and_return(current_branch)
       allow(GitReflow).to receive(:git_server).and_return(github)
       stub_request(:post, %r{/repos/#{user}/#{repo}/pulls}).
         to_return(body: Fixture.new('pull_requests/pull_request.json').to_s, status: 201, headers: {content_type: "application/json; charset=utf-8"})
@@ -179,7 +179,7 @@ describe GitReflow::GitServer::GitHub do
     specify { expect(subject.class.to_s).to eq('GitReflow::GitServer::GitHub::PullRequest') }
 
     it 'creates a pull request using the remote user and repo' do
-      github_api.stub(:pull_requests)
+      allow(github_api).to receive(:pull_requests)
       expect(github_api.pull_requests).to receive(:create).with(user, repo, title: title, body: body, head: "#{user}:#{current_branch}", base: 'master').and_return(existing_pull_request)
       subject
     end
@@ -189,25 +189,25 @@ describe GitReflow::GitServer::GitHub do
     subject { github.find_open_pull_request({ from: 'new-feature', to: 'master'}) }
 
     it 'looks for an open pull request matching the remote user/repo' do
-      subject.number.should == existing_pull_requests.first.number
+      expect(subject.number).to eq(existing_pull_requests.first.number)
     end
 
     context 'no pull request exists' do
       before do
-        github_api.stub(:pull_requests)
-        github_api.pull_requests.should_receive(:all).and_return([])
+        allow(github_api).to receive(:pull_requests)
+        expect(github_api.pull_requests).to receive(:all).and_return([])
       end
-      it     { should == nil }
+      it     { is_expected.to eq(nil) }
     end
   end
 
   describe '#get_build_status(sha)' do
     let(:sha) { '6dcb09b5b57875f334f61aebed695e2e4193db5e' }
     subject   { github.get_build_status(sha) }
-    before    { github_api.stub_chain(:repos, :statuses) }
+    before    { allow(github_api).to receive_message_chain(:repos, :statuses) }
 
     it 'gets the latest build status for the given commit hash' do
-      github_api.repos.statuses.should_receive(:all).with(user, repo, sha).and_return([{ state: 'success'}])
+      expect(github_api.repos.statuses).to receive(:all).with(user, repo, sha).and_return([{ state: 'success'}])
       subject
     end
   end