git_reflow 0.8.4 → 0.8.6

data/spec/lib/git_reflow_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe GitReflow do
-
-  describe ".default_editor" do
-    subject { GitReflow.default_editor }
-
-    context "when the environment has EDITOR set" do
-      before  { allow(ENV).to receive(:[]).with('EDITOR').and_return('emacs') }
-      specify { expect( subject ).to eql('emacs') }
-    end
-
-    context "when the environment has no EDITOR set" do
-      before  { allow(ENV).to receive(:[]).with('EDITOR').and_return(nil) }
-      specify { expect( subject ).to eql('vi') }
-    end
-  end
-
-  describe ".git_server" do
-    subject { GitReflow.git_server }
-
-    before do
-      allow(GitReflow::Config).to receive(:get).with('reflow.git-server').and_return('GitHub ')
-    end
-
-    it "attempts to connect to the provider" do
-      expect(GitReflow::GitServer).to receive(:connect).with(provider: 'GitHub', silent: true)
-      subject
-    end
-  end
-
-  context "aliases workflow commands" do
-    %w{deliver refresh review setup stage start status}.each do |command|
-      it "aliases the command to the workflow" do
-        expect( subject.respond_to?(command.to_sym) ).to be_truthy
-      end
-    end
-  end
-end

data/spec/lib/git_server/bit_bucket_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-
-describe GitReflow::GitServer::BitBucket do
-  let(:user)         { 'reenhanced' }
-  let(:password)     { 'shazam' }
-  let(:repo)         { 'repo' }
-  let(:api_key)      { 'a1b2c3d4e5f6g7h8i9j0' }
-  let(:hostname)     { 'hostname.local' }
-  let(:api_endpoint) { 'https://bitbucket.org/api/1.0' }
-  let(:site)         { 'https://bitbucket.org' }
-  let(:remote_url)   { "git@bitbucket.org:#{user}/#{repo}.git" }
-
-  before do
-    allow_any_instance_of(HighLine).to receive(:ask) do |terminal, question|
-      values = {
-        "Please enter your BitBucket username: " => user
-      }
-     return_value = values[question]
-     question = ""
-     return_value
-    end
-  end
-
-  describe '#initialize(options)' do
-    subject { GitReflow::GitServer::BitBucket.new({}) }
-
-    it 'sets the reflow git server provider to BitBucket in the git config' do
-      expect(GitReflow::Config).to receive(:set).once.with('reflow.git-server', 'BitBucket', local: false)
-      subject
-    end
-
-    context 'storing git config settings only for this project' 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
-        expect(GitReflow::Config).to receive(:set).once.with('reflow.git-server', 'BitBucket', local: true)
-        subject
-      end
-    end
-
-  end
-
-  describe '#authenticate' do
-    let(:bitbucket)      { GitReflow::GitServer::BitBucket.new( { }) }
-    let!(:bitbucket_api) { BitBucket.new }
-    subject              { bitbucket.authenticate }
-
-    context 'already authenticated' do
-      it "notifies the user of successful setup" do
-        allow(GitReflow::Config).to receive(:set).with('reflow.git-server', 'BitBucket', local: false)
-        allow(GitReflow::Config).to receive(:get).with('remote.origin.url').and_return(remote_url)
-        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_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
-          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('')
-          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_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
-  end
-
-end

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

@@ -1,472 +0,0 @@
-require 'spec_helper'
-
-describe GitReflow::GitServer::GitHub::PullRequest do
-  let(:user)                    { 'reenhanced' }
-  let(:password)                { 'shazam' }
-  let(:repo)                    { 'repo' }
-  let(:oauth_token_hash)        { Hashie::Mash.new({ token: 'a1b2c3d4e5f6g7h8i9j0'}) }
-  let(:hostname)                { 'hostname.local' }
-  let(:github_site)             { 'https://github.com' }
-  let(:github_api_endpoint)     { 'https://api.github.com' }
-  let(:enterprise_site)         { 'https://github.gittyup.com' }
-  let(:enterprise_api)          { 'https://github.gittyup.com/api/v3' }
-  let(:github)                  { stub_github_with }
-  let!(:github_api)             { github.connection }
-  let(:existing_pull_request)   { Fixture.new('pull_requests/external_pull_request.json').to_json_hashie }
-  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,
-                repo_name: repo,
-                comments: [{author: comment_author}],
-                pull_request_number: existing_pull_request.number).to_json_hashie }
-  let(:existing_issue_comments) {
-    Fixture.new('issues/comments.json.erb',
-                repo_owner: user,
-                repo_name: repo,
-                comments: [{author: comment_author}],
-                pull_request_number: existing_pull_request.number).to_json_hashie }
-
-  subject { GitReflow::GitServer::GitHub::PullRequest.new(existing_pull_request) }
-
-
-  before do
-    stub_command_line_inputs({
-      "Please enter your GitHub username: "                                                 => user,
-      "Please enter your GitHub password (we do NOT store this): "                          => password,
-      "Please enter your Enterprise site URL (e.g. https://github.company.com):"            => enterprise_site,
-      "Please enter your Enterprise API endpoint (e.g. https://github.company.com/api/v3):" => enterprise_api
-    })
-
-    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
-
-  describe '#initialize(options)' 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(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
-
-  describe '#commit_author' do
-    before do
-      stub_request(:get, %r{#{GitReflow.git_server.class.api_endpoint}/repos/#{user}/#{repo}/pulls/#{existing_pull_request.number}/commits}).
-        with(query: {"access_token" => "a1b2c3d4e5f6g7h8i9j0"}).
-        to_return(:body => Fixture.new("pull_requests/commits.json").to_s, status: 201, headers: {content_type: "application/json; charset=utf-8"})
-    end
-    specify { expect(subject.commit_author).to eql("#{existing_pull_commits.first.commit.author.name} <#{existing_pull_commits.first.commit.author.email}>") }
-  end
-
-  describe '#comments' do
-    context "Testing Appending of Comments" do
-      before do
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            comments: [{author: comment_author}]
-          },
-          issue: {
-            number: existing_pull_request.number,
-            comments: [{author: comment_author}]
-          })
-      end
-      specify { expect(subject.comments).to eql(existing_pull_comments.to_a + existing_issue_comments.to_a) }
-    end
-
-    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.14.0'}).
-         to_return(:status => 200, :body => "", :headers => {})
-
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            comments: nil
-          },
-          issue: {
-            number: existing_pull_request.number,
-            comments: nil
-          })
-      end
-      specify { expect(subject.comments).to eql([]) }
-    end
-  end
-
-  describe '#reviewers' do
-    before do
-      allow(existing_pull_request.user).to receive(:login).and_return('ringo')
-
-      FakeGitHub.new(
-        repo_owner: user,
-        repo_name: repo,
-        pull_request: {
-          number: existing_pull_request.number,
-          owner: existing_pull_request.user.login,
-          comments: [{author: 'tito'}, {author: 'bobby'}, {author: 'ringo'}]
-        },
-        issue: {
-          number: existing_pull_request.number,
-          comments: [{author: 'ringo'}, {author: 'randy'}]
-        })
-    end
-
-    specify { expect(subject.reviewers).to eq(['tito', 'bobby', 'randy']) }
-  end
-
-
-  describe "#approved?" do
-
-    context "no approvals and build success" do
-      before do
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            owner: existing_pull_request.head.user.login,
-            comments: []
-          })
-        allow(GitReflow::GitServer::GitHub::PullRequest).to receive(:minimum_approvals).and_return("0")
-      end
-      specify { expect(subject.approved?).to be_truthy }
-    end
-
-    context "all commenters must approve and minimum_approvals is nil" do
-      before do
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            owner: existing_pull_request.head.user.login,
-            comments: []
-          })
-        allow(GitReflow::GitServer::GitHub::PullRequest).to receive(:minimum_approvals).and_return(nil)
-        allow(subject).to receive(:has_comments?).and_return(true)
-        allow(subject).to receive(:approvals).and_return(["Simon"])
-        allow(subject).to receive(:reviewers_pending_response).and_return([])
-      end
-      specify { expect(subject.approved?).to be_truthy }
-    end
-
-    context "all commenters must approve but we have no pending reviewers" do
-      before do
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            owner: existing_pull_request.head.user.login,
-            comments: []
-          })
-        allow(GitReflow::GitServer::GitHub::PullRequest).to receive(:minimum_approvals).and_return("")
-        allow(subject).to receive(:has_comments?).and_return(true)
-        allow(subject).to receive(:approvals).and_return(["Simon"])
-        allow(subject).to receive(:reviewers_pending_response).and_return([])
-      end
-      specify { expect(subject.approved?).to be_truthy }
-    end
-
-    context "all commenters must approve but we have 1 pending reviewer" do
-      before do
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            owner: existing_pull_request.head.user.login,
-            comments: []
-          })
-        allow(GitReflow::GitServer::GitHub::PullRequest).to receive(:minimum_approvals).and_return("")
-        allow(subject).to receive(:has_comments?).and_return(true)
-        allow(subject).to receive(:approvals).and_return(["Simon"])
-        allow(subject).to receive(:reviewers_pending_response).and_return(["Simon"])
-      end
-      specify { expect(subject.approved?).to be_falsy }
-    end
-
-    context "2 approvals required but we only have 1 approval" do
-      before do
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            owner: existing_pull_request.head.user.login,
-            comments: []
-          })
-        allow(GitReflow::GitServer::GitHub::PullRequest).to receive(:minimum_approvals).and_return("2")
-        allow(subject).to receive(:approvals).and_return(["Simon"])
-        allow(subject).to receive(:last_comment).and_return("LGTM")
-      end
-      specify { expect(subject.approved?).to be_falsy }
-    end
-
-    context "2 approvals required and we have 2 approvals but last comment is not approval" do
-      before do
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            owner: existing_pull_request.head.user.login,
-            comments: []
-          })
-        allow(GitReflow::GitServer::GitHub::PullRequest).to receive(:minimum_approvals).and_return("2")
-        allow(subject).to receive(:approvals).and_return(["Simon", "Peter"])
-        allow(subject).to receive(:last_comment).and_return("Boo")
-      end
-      specify { expect(subject.approved?).to be_falsy }
-    end
-
-    context "2 approvals required and we have 2 approvals and last comment is approval" do
-      before do
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            owner: existing_pull_request.head.user.login,
-            comments: []
-          })
-        allow(GitReflow::GitServer::GitHub::PullRequest).to receive(:minimum_approvals).and_return("2")
-        allow(subject).to receive(:approvals).and_return(["Simon", "Peter"])
-        allow(subject).to receive(:last_comment).and_return("LGTM")
-      end
-      specify { expect(subject.approved?).to be_truthy }
-    end
-  end
-
-  describe '#approvals' do
-    context "no comments" do
-      before do
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            owner: existing_pull_request.head.user.login,
-            comments: []
-          })
-      end
-
-      specify { expect(subject.approvals).to eq([]) }
-    end
-
-    context "single reviewer without approval" do
-      before do
-        FakeGitHub.new(
-          repo_owner: user,
-          repo_name: repo,
-          pull_request: {
-            number: existing_pull_request.number,
-            owner: existing_pull_request.head.user.login,
-            comments: [{author: 'tito', body: 'This is some funky stuff'}]
-          })
-      end
-
-      specify { expect(subject.approvals).to eq([]) }
-    end
-
-    context "single reviewer with approval" do
-      before do
-        FakeGitHub.new(
-          repo_owner:   user,
-          repo_name:    repo,
-          pull_request: {
-            number:   existing_pull_request.number,
-            owner:    existing_pull_request.head.user.login,
-            comments: [{author: 'tito', body: 'LGTM'}]
-          })
-      end
-
-      specify { expect(subject.approvals).to eq(['tito']) }
-
-      context "but a new commit has been introduced" do
-        before do
-          FakeGitHub.new(
-            repo_owner:   user,
-            repo_name:    repo,
-            commits: [
-              {
-                author: user,
-                pull_request_number: existing_pull_request.number,
-                created_at: Chronic.parse("1 second ago")
-              }
-            ],
-            pull_request: {
-              number:   existing_pull_request.number,
-              owner:    existing_pull_request.head.user.login,
-              comments: [{author: 'tito', body: 'LGTM', created_at: Chronic.parse('1 minute ago')}]
-            })
-        end
-
-        specify { expect(subject.approvals).to eq([]) }
-      end
-    end
-
-    context "multiple reviewers with only one approval" do
-      before do
-        FakeGitHub.new(
-          repo_owner:   user,
-          repo_name:    repo,
-          pull_request: {
-            number:   existing_pull_request.number,
-            owner:    existing_pull_request.head.user.login,
-            comments: [{author: 'tito', body: 'LGTM'}, {author: 'ringo', body: 'Needs more cowbell.'}]
-          })
-      end
-
-      specify { expect(subject.approvals).to eq(['tito']) }
-    end
-
-    context "multiple reviewers with all approvals" do
-      before do
-        FakeGitHub.new(
-          repo_owner:   user,
-          repo_name:    repo,
-          pull_request: {
-            number:   existing_pull_request.number,
-            owner:    existing_pull_request.head.user.login,
-            comments: [{author: 'tito', body: 'lgtm'}, {author: 'ringo', body: ':+1:'}]
-          })
-
-        allow(GitReflow::GitServer::GitHub::PullRequest).to receive(:approval_regex).and_return(/(?i-mx:lgtm|looks good to me|:\+1:|:thumbsup:|:shipit:)/)
-      end
-
-      context "2 approvals" do
-        specify { expect(subject.approvals).to eq(['tito', 'ringo']) }
-      end
-
-      context "but a new commit has been introduced" do
-        before do
-          FakeGitHub.new(
-            repo_owner:   user,
-            repo_name:    repo,
-            commits: [
-              {
-                author:              user,
-                pull_request_number: existing_pull_request.number,
-                created_at:          Chronic.parse("1 second ago")
-              }
-            ],
-            pull_request: {
-              number:   existing_pull_request.number,
-              owner:    existing_pull_request.head.user.login,
-              comments: [{author: 'tito', body: 'lgtm', created_at: Chronic.parse('1 minute ago')}, {author: 'ringo', body: ':+1:', created_at: Chronic.parse('1 minute ago')}]
-            })
-        end
-
-        specify { expect(subject.approvals).to eq([]) }
-      end
-    end
-
-  end
-
-  describe '#last_comment' do
-      before do
-        FakeGitHub.new(
-          repo_owner:   user,
-          repo_name:    repo,
-          pull_request: {
-            number:   existing_pull_request.number,
-            owner:    existing_pull_request.head.user.login,
-            comments: [{author: 'tito', body: 'lgtm'}, {author: 'ringo', body: 'Cha cha cha'}]
-          })
-      end
-
-      specify { expect(subject.last_comment).to eq('"Cha cha cha"') }
-  end
-
-  describe '#build' do
-    let(:build) { Fixture.new('repositories/statuses.json').to_json_hashie.first }
-
-    context "with an existing build" do
-      specify { expect(subject.build.state).to eq(build.state) }
-      specify { expect(subject.build.description).to eq(build.description) }
-      specify { expect(subject.build.url).to eq(build.target_url) }
-    end
-
-    context "no build found" do
-      before  { allow(GitReflow.git_server).to receive(:get_build_status).and_return(nil) }
-      specify { expect(subject.build.state).to eq(nil) }
-      specify { expect(subject.build.description).to eq(nil) }
-      specify { expect(subject.build.url).to eq(nil) }
-    end
-  end
-
-
-  describe '.create(options)' do
-    let(:title) { 'Bone Saw is ready!' }
-    let(:body)  { 'Snap into a Slim Jim!' }
-    let(:base_branch_name) { 'base-branch' }
-    let(:pull_request_response) do
-      Fixture.new('pull_requests/pull_request.json.erb',
-                  number:      2,
-                  title:       title,
-                  body:        body,
-                  base_branch: base_branch_name,
-                  repo_owner:  user,
-                  repo_name:   repo)
-    end
-
-    subject { GitReflow::GitServer::GitHub::PullRequest.create(title: title, body: body, base: base_branch_name) }
-
-    before do
-      stub_request(:post, %r{/repos/#{user}/#{repo}/pulls}).
-        to_return(body: pull_request_response.to_s, status: 201, headers: {content_type: "application/json; charset=utf-8"})
-    end
-
-    specify { expect(subject.class.to_s).to eql('GitReflow::GitServer::GitHub::PullRequest') }
-    specify { expect(subject.title).to eql(title) }
-    specify { expect(subject.description).to eql(body) }
-    specify { expect(subject.base_branch_name).to eql(base_branch_name) }
-  end
-
-  describe '.find_open(options)' do
-    let(:feature_branch) { 'new-feature' }
-    let(:base_branch)    { 'base-branch' }
-
-    subject { GitReflow::GitServer::GitHub::PullRequest.find_open(from: feature_branch, to: base_branch) }
-
-    before do
-      allow(GitReflow.git_server.class).to receive(:current_branch).and_return(feature_branch)
-      FakeGitHub.new(
-        repo_owner:   user,
-        repo_name:    repo,
-        pull_request: {
-          number:   existing_pull_request.number,
-          owner:    existing_pull_request.head.user.login,
-          base_branch: base_branch,
-          feature_branch: feature_branch
-        })
-    end
-
-    specify { expect(subject.class.to_s).to eql('GitReflow::GitServer::GitHub::PullRequest') }
-    specify { expect(subject.number).to eql(existing_pull_request.number) }
-
-    context "without any options" do
-      let(:base_branch) { 'master' }
-      subject           { GitReflow::GitServer::GitHub::PullRequest.find_open() }
-      it "defaults to the current branch as the feature branch and 'master' as the base branch" do
-        expect(subject.class.to_s).to eql('GitReflow::GitServer::GitHub::PullRequest')
-        expect(subject.number).to eql(existing_pull_request.number)
-      end
-    end
-  end
-
-end