gitx 2.13.1

data/spec/gitx/cli/nuke_command_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+require 'gitx/cli/nuke_command'
+
+describe Gitx::Cli::NukeCommand do
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
+  end
+  let(:cli) { Gitx::Cli::NukeCommand.new(args, options, config) }
+  let(:branch) { double('fake branch', name: 'feature-branch') }
+
+  before do
+    allow(cli).to receive(:current_branch).and_return(branch)
+  end
+
+  describe '#nuke' do
+    context 'when target branch == prototype and --destination == master' do
+      let(:options) do
+        {
+          destination: good_branch
+        }
+      end
+      let(:good_branch) { 'master' }
+      let(:bad_branch) { 'prototype' }
+      let(:buildtag) { 'build-master-2013-10-01-01' }
+      before do
+        expect(cli).to receive(:yes?).and_return(true)
+
+        expect(cli).to receive(:current_build_tag).with(good_branch).and_return(buildtag)
+
+        expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+        expect(cli).to receive(:run_cmd).with('git branch -D prototype', allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with('git push origin --delete prototype', allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with('git checkout -b prototype build-master-2013-10-01-01').ordered
+        expect(cli).to receive(:run_cmd).with('git push origin prototype').ordered
+        expect(cli).to receive(:run_cmd).with('git branch --set-upstream-to origin/prototype').ordered
+        expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+
+        cli.nuke bad_branch
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when target branch == prototype and destination prompt == nil' do
+      let(:good_branch) { 'master' }
+      let(:bad_branch) { 'prototype' }
+      let(:buildtag) { 'build-master-2013-10-01-01' }
+      before do
+        expect(cli).to receive(:ask).and_return(good_branch)
+        expect(cli).to receive(:yes?).and_return(true)
+
+        expect(cli).to receive(:current_build_tag).with(good_branch).and_return(buildtag)
+
+        expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+        expect(cli).to receive(:run_cmd).with('git branch -D prototype', allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with('git push origin --delete prototype', allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with('git checkout -b prototype build-master-2013-10-01-01').ordered
+        expect(cli).to receive(:run_cmd).with('git push origin prototype').ordered
+        expect(cli).to receive(:run_cmd).with('git branch --set-upstream-to origin/prototype').ordered
+        expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+
+        cli.nuke 'prototype'
+      end
+      it 'defaults to prototype and should run expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when user does not confirm nuking the target branch' do
+      let(:buildtag) { 'build-master-2013-10-01-01' }
+      before do
+        expect(cli).to receive(:ask).and_return('master')
+        expect(cli).to receive(:yes?).and_return(false)
+
+        expect(cli).to receive(:current_build_tag).with('master').and_return(buildtag)
+
+        expect(cli).to_not receive(:run_cmd)
+
+        cli.nuke 'prototype'
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when no valid buildtag is found' do
+      let(:options) do
+        {
+          destination: good_branch
+        }
+      end
+      let(:good_branch) { 'master' }
+      let(:bad_branch) { 'prototype' }
+      let(:buildtags) { '' }
+      it 'raises error' do
+        expect(cli).to receive(:run_cmd).with('git fetch --tags').ordered
+        expect(cli).to receive(:run_cmd).with("git tag -l 'build-master-*'").and_return(buildtags).ordered
+
+        expect { cli.nuke('prototype') }.to raise_error(/No known good tag found for branch/)
+      end
+    end
+    context 'when database migrations exist and user cancels operation' do
+      let(:buildtag) { 'build-master-2013-10-01-01' }
+      let(:good_branch) { 'master' }
+      let(:bad_branch) { 'prototype' }
+      let(:migrations) do
+        %w( db/migrate/20140715194946_create_users.rb db/migrate/20140730063034_update_user_account.rb ).join("\n")
+      end
+      before do
+        FileUtils.mkdir_p('db/migrate')
+
+        expect(cli).to receive(:current_build_tag).with(good_branch).and_return(buildtag)
+
+        expect(cli).to receive(:ask).and_return(good_branch)
+        expect(cli).to receive(:yes?).with('Reset prototype to build-master-2013-10-01-01? (y/n)', :green).and_return(true)
+        expect(cli).to receive(:run_cmd).with('git diff build-master-2013-10-01-01...prototype --name-only db/migrate').and_return(migrations)
+        expect(cli).to receive(:yes?).with('Are you sure you want to nuke prototype? (y/n) ', :green).and_return(false)
+
+        cli.nuke 'prototype'
+      end
+      after do
+        FileUtils.rm_rf('db/migrate')
+      end
+      it 'prompts for nuke confirmation' do
+        should meet_expectations
+      end
+    end
+    context 'when database migrations exist and user approves operation' do
+      let(:buildtag) { 'build-master-2013-10-01-01' }
+      let(:good_branch) { 'master' }
+      let(:bad_branch) { 'prototype' }
+      let(:migrations) do
+        %w( db/migrate/20140715194946_create_users.rb db/migrate/20140730063034_update_user_account.rb ).join("\n")
+      end
+      before do
+        FileUtils.mkdir_p('db/migrate')
+
+        expect(cli).to receive(:current_build_tag).with(good_branch).and_return(buildtag)
+
+        expect(cli).to receive(:ask).and_return(good_branch)
+        expect(cli).to receive(:yes?).with('Reset prototype to build-master-2013-10-01-01? (y/n)', :green).and_return(true)
+        expect(cli).to receive(:run_cmd).with('git diff build-master-2013-10-01-01...prototype --name-only db/migrate').and_return(migrations)
+        expect(cli).to receive(:yes?).with('Are you sure you want to nuke prototype? (y/n) ', :green).and_return(true)
+
+        expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+        expect(cli).to receive(:run_cmd).with('git branch -D prototype', allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with('git push origin --delete prototype', allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with('git checkout -b prototype build-master-2013-10-01-01').ordered
+        expect(cli).to receive(:run_cmd).with('git push origin prototype').ordered
+        expect(cli).to receive(:run_cmd).with('git branch --set-upstream-to origin/prototype').ordered
+        expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+
+        cli.nuke 'prototype'
+      end
+      after do
+        FileUtils.rm_rf('db/migrate')
+      end
+      it 'prompts for nuke confirmation' do
+        should meet_expectations
+      end
+    end
+  end
+end

data/spec/gitx/cli/release_command_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+require 'gitx/cli/release_command'
+
+describe Gitx::Cli::ReleaseCommand do
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
+  end
+  let(:cli) { described_class.new(args, options, config) }
+  let(:branch) { double('fake branch', name: 'feature-branch') }
+  let(:authorization_token) { '123123' }
+
+  before do
+    allow(cli).to receive(:current_branch).and_return(branch)
+  end
+
+  describe '#release' do
+    context 'when user rejects release' do
+      before do
+        expect(cli).to receive(:yes?).and_return(false)
+        expect(cli).to_not receive(:run_cmd)
+
+        cli.release
+      end
+      it 'only runs update commands' do
+        should meet_expectations
+      end
+    end
+    context 'when user confirms release and pull request exists with non-success status' do
+      before do
+        expect(cli).to receive(:execute_command).with(Gitx::Cli::UpdateCommand, :update)
+        expect(cli).to_not receive(:execute_command).with(Gitx::Cli::IntegrateCommand, :integrate, 'staging')
+        expect(cli).to_not receive(:execute_command).with(Gitx::Cli::CleanupCommand, :cleanup)
+
+        expect(cli).to receive(:yes?).with('Release feature-branch to production? (y/n)', :green).and_return(true)
+        expect(cli).to receive(:yes?).with('Branch status is currently: failure.  Proceed with release? (y/n)', :red).and_return(false)
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+
+        expect(cli).to_not receive(:run_cmd).with('git checkout master')
+        expect(cli).to_not receive(:run_cmd).with('git pull origin master')
+        expect(cli).to_not receive(:run_cmd).with('git merge --no-ff feature-branch')
+        expect(cli).to_not receive(:run_cmd).with('git push origin HEAD')
+
+        VCR.use_cassette('pull_request_does_exist_with_failure_status') do
+          cli.release
+        end
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when user confirms release and pull request exists with success status' do
+      before do
+        expect(cli).to receive(:execute_command).with(Gitx::Cli::UpdateCommand, :update)
+        expect(cli).to receive(:execute_command).with(Gitx::Cli::IntegrateCommand, :integrate, 'staging')
+        expect(cli).to_not receive(:execute_command).with(Gitx::Cli::CleanupCommand, :cleanup)
+
+        expect(cli).to receive(:yes?).and_return(true)
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+
+        expect(cli).to receive(:run_cmd).with('git checkout feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+        expect(cli).to receive(:run_cmd).with('git pull origin master').ordered
+        expect(cli).to receive(:run_cmd).with('git merge --no-ff feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with('git push origin HEAD').ordered
+
+        VCR.use_cassette('pull_request_does_exist_with_success_status') do
+          cli.release
+        end
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when target_branch is not nil and user confirms release and pull request exists with success status' do
+      before do
+        expect(cli).to receive(:execute_command).with(Gitx::Cli::UpdateCommand, :update)
+        expect(cli).to receive(:execute_command).with(Gitx::Cli::IntegrateCommand, :integrate, 'staging')
+        expect(cli).to_not receive(:execute_command).with(Gitx::Cli::CleanupCommand, :cleanup)
+
+        expect(cli).to receive(:yes?).and_return(true)
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+
+        expect(cli).to receive(:run_cmd).with('git checkout feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+        expect(cli).to receive(:run_cmd).with('git pull origin master').ordered
+        expect(cli).to receive(:run_cmd).with('git merge --no-ff feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with('git push origin HEAD').ordered
+
+        VCR.use_cassette('pull_request_does_exist_with_success_status') do
+          cli.release 'feature-branch'
+        end
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when user confirms release and pull request does not exist' do
+      let(:new_pull_request) do
+        {
+          html_url: 'https://path/to/html/pull/request',
+          issue_url: 'https://api/path/to/issue/url',
+          number: 10,
+          head: {
+            ref: 'branch_name'
+          }
+        }
+      end
+      before do
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+        allow(cli).to receive(:ask_editor).and_return('description')
+
+        expect(cli).to receive(:execute_command).with(Gitx::Cli::UpdateCommand, :update).twice
+        expect(cli).to receive(:execute_command).with(Gitx::Cli::IntegrateCommand, :integrate, 'staging')
+        expect(cli).to_not receive(:execute_command).with(Gitx::Cli::CleanupCommand, :cleanup)
+
+        expect(cli).to receive(:yes?).with('Release feature-branch to production? (y/n)', :green).and_return(true)
+        expect(cli).to receive(:yes?).with('Branch status is currently: pending.  Proceed with release? (y/n)', :red).and_return(true)
+
+        expect(cli).to receive(:run_cmd).with('git checkout feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with('git checkout feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with("git log master...feature-branch --reverse --no-merges --pretty=format:'* %s%n%b'").and_return('2013-01-01 did some stuff').ordered
+        expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+        expect(cli).to receive(:run_cmd).with('git pull origin master').ordered
+        expect(cli).to receive(:run_cmd).with('git merge --no-ff feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with('git push origin HEAD').ordered
+
+        stub_request(:post, 'https://api.github.com/repos/wireframe/gitx/pulls').to_return(:status => 201, :body => new_pull_request.to_json, :headers => {'Content-Type' => 'application/json'})
+        VCR.use_cassette('pull_request_does_not_exist') do
+          cli.release
+        end
+      end
+      it 'creates pull request on github' do
+        should meet_expectations
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when --cleanup flag passed' do
+      let(:options) do
+        {
+          cleanup: true
+        }
+      end
+      before do
+        expect(cli).to receive(:execute_command).with(Gitx::Cli::UpdateCommand, :update)
+        expect(cli).to receive(:execute_command).with(Gitx::Cli::IntegrateCommand, :integrate, 'staging')
+        expect(cli).to receive(:execute_command).with(Gitx::Cli::CleanupCommand, :cleanup)
+
+        expect(cli).to receive(:yes?).and_return(true)
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+
+        expect(cli).to receive(:run_cmd).with('git checkout feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+        expect(cli).to receive(:run_cmd).with('git pull origin master').ordered
+        expect(cli).to receive(:run_cmd).with('git merge --no-ff feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with('git push origin HEAD').ordered
+
+        VCR.use_cassette('pull_request_does_exist_with_success_status') do
+          cli.release
+        end
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+  end
+end

data/spec/gitx/cli/review_command_spec.rb

@@ -0,0 +1,356 @@
+require 'spec_helper'
+require 'gitx/cli/review_command'
+
+describe Gitx::Cli::ReviewCommand do
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
+  end
+  let(:cli) { described_class.new(args, options, config) }
+  let(:repo) { double('fake repo', config: repo_config) }
+  let(:repo_config) do
+    {
+      'remote.origin.url' => 'https://github.com/wireframe/gitx'
+    }
+  end
+  let(:branch) { double('fake branch', name: 'feature-branch') }
+
+  before do
+    allow(cli).to receive(:repo).and_return(repo)
+    allow(cli).to receive(:current_branch).and_return(branch)
+    allow(cli).to receive(:ask_editor).and_return('description')
+  end
+
+  describe '#review' do
+    context 'when pull request does not exist' do
+      let(:authorization_token) { '123123' }
+      let(:changelog) { '* made some fixes' }
+      let(:fake_update_command) { double('fake update command', update: nil) }
+      let(:new_pull_request) do
+        {
+          html_url: 'https://path/to/html/pull/request',
+          issue_url: 'https://api/path/to/issue/url',
+          number: 10,
+          head: {
+            ref: 'branch_name'
+          }
+        }
+      end
+      before do
+        expect(Gitx::Cli::UpdateCommand).to receive(:new).and_return(fake_update_command)
+
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to receive(:run_cmd).with('git checkout feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with("git log master...feature-branch --reverse --no-merges --pretty=format:'* %s%n%b'").and_return("* old commit\n\n* new commit").ordered
+        expect(cli).to receive(:ask_editor).with("### Changelog\n* old commit\n\n* new commit\n#{Gitx::Github::PULL_REQUEST_FOOTER}", anything).and_return('description')
+
+        stub_request(:post, 'https://api.github.com/repos/wireframe/gitx/pulls').to_return(:status => 201, :body => new_pull_request.to_json, :headers => {'Content-Type' => 'application/json'})
+
+        VCR.use_cassette('pull_request_does_not_exist') do
+          cli.review
+        end
+      end
+      it 'creates github pull request' do
+        should meet_expectations
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when target branch is not nil and pull request does not exist' do
+      let(:authorization_token) { '123123' }
+      let(:changelog) { '* made some fixes' }
+      let(:fake_update_command) { double('fake update command', update: nil) }
+      let(:new_pull_request) do
+        {
+          html_url: 'https://path/to/html/pull/request',
+          issue_url: 'https://api/path/to/issue/url',
+          number: 10,
+          head: {
+            ref: 'branch_name'
+          }
+        }
+      end
+      before do
+        expect(Gitx::Cli::UpdateCommand).to receive(:new).and_return(fake_update_command)
+
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to receive(:run_cmd).with('git checkout feature-branch').ordered
+        expect(cli).to receive(:run_cmd).with("git log master...feature-branch --reverse --no-merges --pretty=format:'* %s%n%b'").and_return("* old commit\n\n* new commit").ordered
+        expect(cli).to receive(:ask_editor).with("### Changelog\n* old commit\n\n* new commit\n#{Gitx::Github::PULL_REQUEST_FOOTER}", anything).and_return('description')
+
+        stub_request(:post, 'https://api.github.com/repos/wireframe/gitx/pulls').to_return(:status => 201, :body => new_pull_request.to_json, :headers => {'Content-Type' => 'application/json'})
+
+        VCR.use_cassette('pull_request_does_not_exist') do
+          cli.review 'feature-branch'
+        end
+      end
+      it 'creates github pull request' do
+        should meet_expectations
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when authorization_token is missing' do
+      let(:authorization_token) { nil }
+      it do
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect { cli.review }.to raise_error(/token not found/)
+      end
+    end
+    context 'when pull request already exists' do
+      let(:authorization_token) { '123123' }
+      before do
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to_not receive(:create_pull_request)
+
+        VCR.use_cassette('pull_request_does_exist_with_success_status') do
+          cli.review
+        end
+      end
+      it 'does not create new pull request' do
+        should meet_expectations
+      end
+    end
+    context 'when --assignee option passed' do
+      let(:options) do
+        {
+          assignee: 'johndoe'
+        }
+      end
+      let(:authorization_token) { '123123' }
+      before do
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+
+        stub_request(:patch, /.*api.github.com.*/).to_return(:status => 200)
+
+        VCR.use_cassette('pull_request_does_exist_with_success_status') do
+          cli.review
+        end
+      end
+      it 'updates github pull request' do
+        expect(WebMock).to have_requested(:patch, 'https://api.github.com/repos/wireframe/gitx/issues/10')
+      end
+    end
+    context 'when --open flag passed' do
+      let(:options) do
+        {
+          open: true
+        }
+      end
+      let(:authorization_token) { '123123' }
+      before do
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to receive(:run_cmd).with('open https://path/to/html/pull/request').ordered
+        VCR.use_cassette('pull_request_does_exist_with_success_status') do
+          cli.review
+        end
+      end
+      it 'runs open command with pull request url' do
+        should meet_expectations
+      end
+    end
+    context 'when --bump flag is passed' do
+      let(:options) do
+        {
+          bump: true
+        }
+      end
+      let(:authorization_token) { '123123' }
+      let(:reference) { double('fake reference', target_id: 'e12da4') }
+      before do
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to receive(:ask_editor).and_return('comment description')
+        allow(repo).to receive(:head).and_return(reference)
+        stub_request(:post, /.*api.github.com.*/).to_return(:status => 201)
+
+        VCR.use_cassette('pull_request_does_exist_with_success_status') do
+          cli.review
+        end
+      end
+      it 'posts comment to github' do
+        expect(WebMock).to have_requested(:post, 'https://api.github.com/repos/wireframe/gitx/issues/10/comments').
+          with(body: {body: "[gitx] review bump :tada:\n\ncomment description"})
+      end
+      it 'creates pending build status for latest commit' do
+        expect(WebMock).to have_requested(:post, 'https://api.github.com/repos/wireframe/gitx/statuses/e12da4').
+          with(body: {state: 'pending', context: 'peer_review', description: 'Peer review in progress'})
+      end
+    end
+    context 'when --reject flag is passed' do
+      let(:options) do
+        {
+          reject: true
+        }
+      end
+      let(:authorization_token) { '123123' }
+      let(:reference) { double('fake reference', target_id: 'e12da4') }
+      before do
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to receive(:ask_editor).and_return('comment body')
+        allow(repo).to receive(:head).and_return(reference)
+        stub_request(:post, /.*api.github.com.*/).to_return(:status => 201)
+
+        VCR.use_cassette('pull_request_does_exist_with_success_status') do
+          cli.review
+        end
+      end
+      it 'posts comment to github' do
+        expect(WebMock).to have_requested(:post, 'https://api.github.com/repos/wireframe/gitx/issues/10/comments').
+          with(body: {body: "[gitx] review rejected\n\ncomment body"})
+      end
+      it 'creates failure build status for latest commit' do
+        expect(WebMock).to have_requested(:post, 'https://api.github.com/repos/wireframe/gitx/statuses/e12da4').
+          with(body: {state: 'failure', context: 'peer_review', description: 'Peer review rejected'})
+      end
+    end
+    context 'when --approve flag is passed' do
+      let(:options) do
+        {
+          approve: true
+        }
+      end
+      let(:authorization_token) { '123123' }
+      let(:reference) { double('fake reference', target_id: 'e12da4') }
+      before do
+        allow(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to receive(:ask_editor).and_return('comment body')
+        allow(repo).to receive(:head).and_return(reference)
+        stub_request(:post, /.*api.github.com.*/).to_return(:status => 201)
+
+        VCR.use_cassette('pull_request_does_exist_with_success_status') do
+          cli.review
+        end
+      end
+      it 'posts comment to github' do
+        expect(WebMock).to have_requested(:post, 'https://api.github.com/repos/wireframe/gitx/issues/10/comments').
+          with(body: {body: "[gitx] review approved :shipit:\n\ncomment body"})
+      end
+      it 'creates success build status for latest commit' do
+        expect(WebMock).to have_requested(:post, 'https://api.github.com/repos/wireframe/gitx/statuses/e12da4').
+          with(body: {state: 'success', context: 'peer_review', description: 'Peer review approved'})
+      end
+    end
+  end
+
+  describe '#authorization_token' do
+    context 'when github.user is not configured' do
+      it 'raises error' do
+        expect do
+          cli.send(:authorization_token)
+        end.to raise_error(/Github user not configured/)
+      end
+    end
+    context 'when ENV[GITX_GITHUB_TOKEN] is set' do
+      let(:auth_token) { '123123' }
+      before do
+        ENV['GITX_GITHUB_TOKEN'] = auth_token
+        expect(cli).to_not receive(:ask)
+        @auth_token = cli.send(:authorization_token)
+      end
+      after do
+        ENV.delete('GITX_GITHUB_TOKEN')
+      end
+      it { expect(@auth_token).to eq auth_token }
+      it { is_expected.to meet_expectations }
+    end
+    context 'when global config token is nil' do
+      let(:repo_config) do
+        {
+          'remote.origin.url' => 'https://github.com/wireframe/gitx',
+          'github.user' => 'ryan@codecrate.com'
+        }
+      end
+      let(:github_password) { 'secretz' }
+      let(:authorization_token) { '123981239123' }
+      before do
+        stub_request(:post, 'https://ryan@codecrate.com:secretz@api.github.com/authorizations').
+          to_return(:status => 200, :body => JSON.dump(token: authorization_token), :headers => {'Content-Type' => 'application/json'})
+
+        expect(cli).to receive(:ask).with('Github password for ryan@codecrate.com: ', {:echo => false}).and_return(github_password)
+        expect(cli).to receive(:ask).with('Github two factor authorization token (if enabled): ', {:echo => false}).and_return(nil)
+
+        @auth_token = cli.send(:authorization_token)
+      end
+      it 'stores authorization_token in global config' do
+        expect(global_config).to include('token' => authorization_token)
+      end
+      it { expect(@auth_token).to eq authorization_token }
+    end
+    context 'when global authorization_token is nil and first request fails' do
+      let(:repo_config) do
+        {
+          'remote.origin.url' => 'https://github.com/wireframe/gitx',
+          'github.user' => 'ryan@codecrate.com'
+        }
+      end
+      let(:github_password) { 'secretz' }
+      let(:authorization_token) { '123981239123' }
+      before do
+        stub_request(:post, 'https://ryan@codecrate.com:secretz@api.github.com/authorizations').
+          to_return(:status => 401, :body => JSON.dump(token: authorization_token), :headers => {'Content-Type' => 'application/json'}).
+          then.
+          to_return(:status => 200, :body => JSON.dump(token: authorization_token), :headers => {'Content-Type' => 'application/json'})
+
+        expect(cli).to receive(:ask).with('Github password for ryan@codecrate.com: ', {:echo => false}).and_return(github_password).twice
+        expect(cli).to receive(:ask).with('Github two factor authorization token (if enabled): ', {:echo => false}).and_return(nil).twice
+
+        @auth_token = cli.send(:authorization_token)
+      end
+      it 'stores authorization_token in global config' do
+        expect(global_config).to include('token' => authorization_token)
+      end
+      it { expect(@auth_token).to eq authorization_token }
+    end
+    context 'when the global config has an existing token' do
+      let(:authorization_token) { '123981239123' }
+      let(:repo_config) do
+        {
+          'remote.origin.url' => 'https://github.com/wireframe/gitx',
+          'github.user' => 'ryan@codecrate.com'
+        }
+      end
+      let(:config) do
+        {
+          'token' => authorization_token
+        }
+      end
+      before do
+        File.open(global_config_file, 'w') do |file|
+          file.write(config.to_yaml)
+        end
+        @auth_token = cli.send(:authorization_token)
+      end
+      it { expect(@auth_token).to eq authorization_token }
+    end
+    context 'when two factor authorization token given' do
+      let(:repo_config) do
+        {
+          'remote.origin.url' => 'https://github.com/wireframe/gitx',
+          'github.user' => 'ryan@codecrate.com'
+        }
+      end
+      let(:github_password) { 'secretz' }
+      let(:authorization_token) { '123981239123' }
+      let(:two_factor_auth_token) { '456456' }
+      before do
+        stub_request(:post, 'https://ryan@codecrate.com:secretz@api.github.com/authorizations').
+          with(headers: {'X-GitHub-OTP' => two_factor_auth_token}).
+          to_return(:status => 200, :body => JSON.dump(token: authorization_token), :headers => {'Content-Type' => 'application/json'})
+
+        expect(cli).to receive(:ask).with('Github password for ryan@codecrate.com: ', {:echo => false}).and_return(github_password)
+        expect(cli).to receive(:ask).with('Github two factor authorization token (if enabled): ', {:echo => false}).and_return(two_factor_auth_token)
+
+        @auth_token = cli.send(:authorization_token)
+      end
+      it 'stores authorization_token in global config' do
+        expect(global_config).to include('token' => authorization_token)
+      end
+      it { expect(@auth_token).to eq authorization_token }
+    end
+  end
+end