git_reflow 0.3.5 → 0.4.0

data/spec/lib/git_reflow/git_helpers_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe GitReflow::GitHelpers do
+  let(:origin_url) { 'git@github.com:reenhanced.spectacular/this-is-the.shit.git' }
+
+  before do
+    stub_with_fallback(GitReflow::Config, :get).with('remote.origin.url').and_return(origin_url)
+
+    module Gitacular
+      include GitReflow::GitHelpers
+      extend self
+    end
+
+    stub_run_for Gitacular
+  end
+
+  describe ".remote_user" do
+    subject { Gitacular.remote_user }
+
+    it { should == 'reenhanced.spectacular' }
+
+    context "remote origin url isn't set" do
+      let(:origin_url) { nil }
+      it { should == '' }
+    end
+  end
+
+  describe ".remote_repo_name" do
+    subject { Gitacular.remote_repo_name }
+
+    it { should == 'this-is-the.shit' }
+
+    context "remote origin url isn't set" do
+      let(:origin_url) { nil }
+      it { should == '' }
+    end
+  end
+
+  describe ".current_branch" do
+    subject { Gitacular.current_branch }
+    it      { expect{ subject }.to have_run_command_silently "git branch --no-color | grep '^\* ' | grep -v 'no branch' | sed 's/^* //g'" }
+  end
+
+  describe ".get_first_commit_message" do
+    subject { Gitacular.get_first_commit_message }
+    it      { expect{ subject }.to have_run_command_silently 'git log --pretty=format:"%s" --no-merges -n 1' }
+  end
+
+  describe ".push_current_branch" do
+    subject { Gitacular.push_current_branch }
+    before  { Gitacular.stub(:current_branch).and_return('bingo') }
+    it      { expect{ subject }.to have_run_command "git push origin bingo" }
+  end
+
+  describe ".fetch_destination(destination_branch)" do
+    subject { Gitacular.fetch_destination('new-feature') }
+    it      { expect{ subject }.to have_run_command "git fetch origin new-feature" }
+  end
+
+  describe ".update_destination(destination_branch)" do
+    let(:current_branch)     { 'bananas' }
+    let(:destination_branch) { 'monkey-business' }
+
+    before  { Gitacular.stub(: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
+      expect { subject }.to have_run_commands_in_order [
+        "git checkout #{destination_branch}",
+        "git pull origin #{destination_branch}",
+        "git checkout #{current_branch}"
+      ]
+    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) }
+
+    it 'checks out master as the default destination branch and squash merges the feature branch' do
+      expect { subject }.to have_run_commands_in_order [
+        'git checkout master',
+        "git merge --squash #{feature_branch}"
+      ]
+    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
+    let(:message) { "do do the voodoo that you do" }
+    subject { Gitacular.append_to_squashed_commit_message(message) }
+    it "appends the message to git's SQUASH_MSG temp file" do
+      expect{ subject }.to have_run_commands_in_order [
+        "echo \"#{message}\" | cat - .git/SQUASH_MSG > ./tmp_squash_msg",
+        'mv ./tmp_squash_msg .git/SQUASH_MSG'
+      ]
+    end
+  end
+end

data/spec/lib/git_reflow/git_server_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe GitReflow::GitServer do
+  let(:connection_options) { nil }
+
+  subject { GitReflow::GitServer.connect connection_options }
+
+  before do
+    GitReflow::GitServer::GitHub.stub(:new)
+
+    module GitReflow::GitServer
+      class DummyHub < Base
+        def initialize(options)
+          "Initialized with #{options}"
+        end
+
+        def authenticate(options={})
+        end
+
+        def connection
+          'Connected!'
+        end
+      end
+    end
+  end
+
+  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)
+      subject
+    end
+
+    context 'provider is specified' do
+      let(:connection_options) { {provider: 'DummyHub'}.merge(expected_server_options) }
+      let(:expected_server_options) {{ basic_auth: 'user:pass', end_point: 'https://api.example.com' }}
+
+      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'
+      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\"" }
+    end
+  end
+
+  describe '.current_provider' do
+    subject { GitReflow::GitServer.current_provider }
+
+    context 'Reflow setup to use GitHub' do
+      before { GitReflow::Config.stub(:get).with('reflow.git-server').and_return('GitHub') }
+      it     { should == 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" }
+    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') }
+
+      it { should be_nil }
+      it { expect{ subject }.to have_output "GitServer not setup for \"GittyUp\"" }
+    end
+  end
+
+  describe '.connection' do
+    subject { GitReflow::GitServer.connection }
+
+    it { should be_nil }
+
+    context "with a valid provider" do
+      before { GitReflow::Config.stub(:get).with('reflow.git-server').and_return('GitHub') }
+      it 'calls connection on the provider' do
+        GitReflow::GitServer::GitHub.should_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\"" }
+    end
+  end
+end

data/spec/lib/git_server/git_hub_spec.rb

@@ -0,0 +1,236 @@
+require 'spec_helper'
+
+describe GitReflow::GitServer::GitHub 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(pull: existing_pull_request) }
+  let!(:github_api)            { github.connection }
+  let(:existing_pull_request)  { Hashie::Mash.new JSON.parse(fixture('pull_requests/pull_request.json').read) }
+  let(:existing_pull_requests) { JSON.parse(fixture('pull_requests/pull_requests.json').read).collect {|pull| Hashie::Mash.new pull } }
+
+  before do
+    HighLine.any_instance.stub(:ask) do |terminal, question|
+      values = {
+        "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
+      }
+     return_value = values[question]
+     question = ""
+     return_value
+    end
+
+    github.stub(:remote_user).and_return(user)
+    github.stub(:remote_repo_name).and_return(repo)
+    github.stub(:run).with('hostname', loud: false).and_return(hostname)
+  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')
+      subject
+    end
+
+    context 'using enterprise' 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')
+        subject
+      end
+
+    end
+
+    context 'storing git config settings only for this project' do
+      subject { GitReflow::GitServer::GitHub.new(project_only: 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', 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)
+        subject
+      end
+    end
+
+  end
+
+  describe '#authenticate' do
+    let(:github)                { GitReflow::GitServer::GitHub.new({}) }
+    let!(:github_api)           { Github.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)
+    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)
+        end
+
+        it "notifies the user of successful setup" do
+          expect { subject }.to have_output "\nYour GitHub account was successfully setup!"
+        end
+
+        it "creates a new GitHub oauth token" do
+          github_api.oauth.should_receive(:create).and_return(oauth_token_hash)
+          subject
+        end
+
+        it "creates git config keys for github connections" do
+          expect{ subject }.to have_run_command_silently "git config --global --replace-all github.site \"#{GitReflow::GitServer::GitHub.site_url}\""
+          expect{ subject }.to have_run_command_silently "git config --global --replace-all github.endpoint \"#{GitReflow::GitServer::GitHub.api_endpoint}\""
+          expect{ subject }.to have_run_command_silently "git config --global --replace-all github.oauth-token \"#{oauth_token_hash[:token]}\""
+          expect{ subject }.to have_run_command_silently "git config --global --replace-all reflow.git-server \"GitHub\""
+        end
+
+        context "exclusive to project" do
+          let(:github) { GitReflow::GitServer::GitHub.new(project_only: true) }
+          before       { GitReflow::GitServer::GitHub.stub(:@project_only).and_return(true) }
+
+          it "creates _local_ git config keys for github connections" do
+            expect{ subject }.to_not have_run_command_silently "git config --global --replace-all github.site \"#{GitReflow::GitServer::GitHub.site_url}\""
+            expect{ subject }.to_not have_run_command_silently "git config --global --replace-all github.endpoint \"#{GitReflow::GitServer::GitHub.api_endpoint}\""
+            expect{ subject }.to_not have_run_command_silently "git config --global --replace-all github.oauth-token \"#{oauth_token_hash[:token]}\""
+            expect{ subject }.to_not have_run_command_silently "git config --global --replace-all reflow.git-server \"GitHub\""
+
+            expect{ subject }.to have_run_command_silently "git config --replace-all github.site \"#{GitReflow::GitServer::GitHub.site_url}\""
+            expect{ subject }.to have_run_command_silently "git config --replace-all github.endpoint \"#{GitReflow::GitServer::GitHub.api_endpoint}\""
+            expect{ subject }.to have_run_command_silently "git config --replace-all github.oauth-token \"#{oauth_token_hash[:token]}\""
+            expect{ subject }.to have_run_command_silently "git config --replace-all reflow.git-server \"GitHub\""
+          end
+        end
+
+        context "use GitHub enterprise account" do
+          let(:github) { GitReflow::GitServer::GitHub.new(enterprise: true) }
+          before { GitReflow::GitServer::GitHub.stub(:@using_enterprise).and_return(true) }
+          it "creates git config keys for github connections" do
+            expect{ subject }.to have_run_command_silently "git config --global --replace-all github.site \"#{enterprise_site}\""
+            expect{ subject }.to have_run_command_silently "git config --global --replace-all github.endpoint \"#{enterprise_api}\""
+            expect{ subject }.to have_run_command_silently "git config --global --replace-all github.oauth-token \"#{oauth_token_hash[:token]}\""
+            expect{ subject }.to have_run_command_silently "git config --global --replace-all reflow.git-server \"GitHub\""
+          end
+        end
+      end
+
+      context "with invalid GitHub credentials" do
+        let(:unauthorized_error_response) {{
+          response_headers: {'content-type' => 'application/json; charset=utf-8', status: 'Unauthorized'},
+          method: 'GET',
+          status: '401',
+          body: { error: "GET https://api.github.com/authorizations: 401 Bad credentials" }
+        }}
+
+        before do
+          Github.should_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 "\nInvalid username or password: #{Github::Error::Unauthorized.new(unauthorized_error_response).inspect}"
+        end
+      end
+    end
+  end
+
+  describe '#create_pull_request(options)' do
+    let(:title)          { 'Fresh title' }
+    let(:body)           { 'Funky body' }
+    let(:current_branch) { 'new-feature' }
+
+    before { github.stub(:current_branch).and_return(current_branch) }
+
+    it 'creates a pull request using the remote user and repo' do
+      github_api.stub(:pull_requests)
+      github_api.pull_requests.should_receive(:create).with(user, repo, title: title, body: body, head: "#{user}:#{current_branch}", base: 'master')
+      github.create_pull_request({ title: title, body: body, base: 'master' })
+    end
+  end
+
+  describe '#find_pull_request(from, to)' do
+    subject { github.find_pull_request({ from: 'new-feature', to: 'master'}) }
+
+    it 'looks for an open pull request matching the remote user/repo' do
+      subject.should == existing_pull_requests.first
+    end
+
+    context 'no pull request exists' do
+      before { github.stub(:find_pull_request).and_return([]) }
+      it     { should == [] }
+    end
+  end
+
+  describe '#pull_request_comments(pull_request)' do
+    let(:pull_request_comments) { JSON.parse(fixture('pull_requests/comments.json').read).collect {|c| Hashie::Mash.new(c) } }
+
+    subject { github.pull_request_comments(existing_pull_request) }
+
+    before do
+      github_api.stub_chain(:issues, :comments)
+      github_api.stub_chain(:pull_requests, :comments)
+    end
+
+    it 'includes both issue comments and pull request comments' do
+      github_api.issues.comments.should_receive(:all).with(user, repo, number: existing_pull_request.number).and_return([pull_request_comments.first])
+      github_api.pull_requests.comments.should_receive(:all).with(user, repo, number: existing_pull_request.number).and_return([pull_request_comments.first])
+      subject.count.should == 2
+    end
+  end
+
+  describe '#has_pull_request_comments?(pull_request)' do
+    let(:existing_pull_request) { Hashie::Mash.new JSON.parse(fixture('pull_requests/pull_request.json').read) }
+    let(:pull_request_comments) { JSON.parse(fixture('pull_requests/comments.json').read).collect {|c| Hashie::Mash.new(c) } }
+
+    before  { github.stub(:pull_request_comments).and_return([pull_request_comments]) }
+    subject { github.has_pull_request_comments?(existing_pull_request) }
+
+    it { should == true }
+
+    context 'no comments exist for the given pull request' do
+      before { github.stub(:pull_request_comments).and_return([]) }
+      it     { should == false }
+    end
+  end
+
+  describe '#get_build_status(sha)' do
+    let(:sha) { '6dcb09b5b57875f334f61aebed695e2e4193db5e' }
+    subject   { github.get_build_status(sha) }
+    before    { github_api.stub_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'}])
+      subject
+    end
+  end
+
+  describe '#find_authors_of_open_pull_request_comments(pull_request)' do
+  end
+
+  describe '#comment_authors_for_pull_request(pull_request, options = {})' do
+  end
+
+  describe '#get_commited_time(commit_sha)' do
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'rspec'
+require 'multi_json'
+require 'webmock/rspec'
+require 'pry'
+
+$LOAD_PATH << 'lib'
+require 'git_reflow'
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each {|f| require f}
+
+RSpec.configure do |config|
+  config.include GithubHelpers
+  config.include WebMock::API
+  config.include CommandLineHelpers
+  config.include GithubHelpers
+  config.include RspecStubHelpers
+
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+
+  config.before(:each) do
+    WebMock.reset!
+    stub_command_line
+    allow_message_expectations_on_nil
+  end
+
+  config.after(:each) do
+    WebMock.reset!
+    reset_stubbed_command_line
+  end
+end

data/spec/support/command_line_helpers.rb

@@ -0,0 +1,99 @@
+module CommandLineHelpers
+  def stub_command_line
+    $commands_ran = []
+    $output       = []
+
+    stub_run_for GitReflow
+    stub_run_for GitReflow::Sandbox
+
+    STDOUT.stub(:puts) do |output|
+      $output << output
+      output = ''
+    end
+  end
+
+  def stub_run_for(module_to_stub)
+    module_to_stub.stub(:run) do |command, options|
+      options ||= {}
+      $commands_ran << Hashie::Mash.new(command: command, options: options)
+      command = "" # we need this due to a bug in rspec that will keep this assignment on subsequent runs of the stub
+    end
+  end
+
+  def reset_stubbed_command_line
+    $commands_ran = []
+  end
+
+  def stub_command(command, return_value)
+    GitReflow::Sandbox.stub(:run).with(command).and_return(return_value)
+  end
+end
+
+RSpec::Matchers.define :have_run_command do |command|
+  match do |block|
+    block.call
+    (
+      $commands_ran.include? Hashie::Mash.new(command: command, options: {}) or
+      $commands_ran.include? Hashie::Mash.new(command: command, options: {with_system: true})
+    )
+  end
+
+  supports_block_expectations
+
+  failure_message do |block|
+    "expected to have run the command \`#{command}\` but instead ran:\n\t#{$commands_ran.inspect}"
+  end
+end
+
+RSpec::Matchers.define :have_run_command_silently do |command|
+  match do |block|
+    block.call
+    $commands_ran.include? Hashie::Mash.new(command: command, options: { loud: false })
+  end
+
+  supports_block_expectations
+
+  failure_message do |block|
+    "expected to have run the command \`#{command}\` silently but instead ran:\n\t#{$commands_ran.inspect}"
+  end
+end
+
+RSpec::Matchers.define :have_run_commands_in_order do |commands|
+  match do |block|
+    block.call
+    command_count = commands.count
+    command_start_index = $commands_ran.reverse.find_index {|c| c.command == commands.first }
+    return false unless command_start_index
+
+    $commands_ran.reverse.each_with_index do |command_ran, index|
+      next unless command_start_index
+      if command_count >= 1
+        current_command = commands[command_count - 1]
+        current_command.should == command_ran.command
+        command_count -= 1
+      end
+    end
+
+    return command_count == 0
+  end
+
+  supports_block_expectations
+
+  failure_message do |block|
+    "expected to have run these commands in order:\n\t\t#{commands.inspect}\n\tgot:\n\t\t#{$commands_ran.inspect}"
+  end
+end
+
+RSpec::Matchers.define :have_output do |expected_output|
+  match do |block|
+    block.call
+    $output.include? expected_output
+  end
+
+  supports_block_expectations
+
+  failure_message do |block|
+    "expected STDOUT to include #{expected_output} but didn't: \n\t#{$output.inspect}"
+  end
+end
+

data/spec/support/fixtures.rb

@@ -0,0 +1,8 @@
+def fixture_path
+  File.expand_path("../../fixtures", __FILE__)
+end
+
+def fixture(file)
+  File.new(File.join(fixture_path, '/', file))
+end
+