git-process-lib 2.0.0

data/spec/github_configuration_spec.rb

@@ -0,0 +1,152 @@
+require 'git-process/github_configuration'
+require 'json'
+require 'github_test_helper'
+
+
+describe GitHubService::Configuration, :git_repo_helper do
+  include GitHubTestHelper
+
+
+  def test_token
+    'hfgkdjfgksjhdfkls'
+  end
+
+
+  def ghc
+    @ghc ||= GitHubService::Configuration.new(gitlib.config, :user => 'tu', :password => 'dfsdf')
+  end
+
+
+  describe 'create_authorization' do
+
+    it "should return an auth_token for a good request" do
+      gitlib.remote.add('origin', 'git@github.com:jdigger/git-process.git')
+      stub_post('https://tu:dfsdf@api.github.com/authorizations', :send => auth_json,
+                :body => {:token => test_token})
+
+      ghc.create_authorization().should == test_token
+    end
+
+
+    it 'should 401 for bad password' do
+      gitlib.remote.add('origin', 'git@github.com:jdigger/git-process.git')
+      stub_post('https://tu:dfsdf@api.github.com/authorizations', :send => auth_json,
+                :status => 401)
+
+      expect { ghc.create_authorization() }.to raise_error Octokit::Unauthorized
+    end
+
+  end
+
+
+  describe "auth_token no username or password" do
+
+    it "should get the token from config if it exists" do
+      gitlib.config['github.user'] = 'test_user'
+      gitlib.config['gitProcess.github.authToken'] = test_token
+
+      ghc.auth_token.should == test_token
+    end
+
+  end
+
+
+  describe 'auth_token with password but no username' do
+
+    def ghc
+      @ghc ||= GitHubService::Configuration.new(gitlib.config, :user => nil, :password => 'dfsdf')
+    end
+
+
+    it 'should get the token from the server if it does not exist in config' do
+      gitlib.remote.add('origin', 'git@github.com:jdigger/git-process.git')
+      gitlib.config['github.user'] = 'test_user'
+      gitlib.config['gitProcess.github.authToken'] = ''
+
+      stub_post('https://test_user:dfsdf@api.github.com/authorizations', :send => auth_json,
+                :body => {:token => test_token})
+
+      ghc.auth_token.should == test_token
+    end
+
+  end
+
+
+  describe "user" do
+
+    def ghc
+      @ghc ||= GitHubService::Configuration.new(gitlib.config, :user => nil, :password => 'dfsdf')
+    end
+
+
+    it "should get the value from config" do
+      gitlib.config['github.user'] = 'test_user'
+
+      ghc.user.should == 'test_user'
+    end
+
+
+    it "should prompt the user and store it in the config" do
+      gitlib.config['github.user'] = ''
+
+      GitHubService::Configuration.stub(:ask_for_user).and_return('test_user')
+      ghc.user.should == 'test_user'
+    end
+
+  end
+
+
+  describe "using GHE instead of GitHub.com" do
+
+    it "should use the correct server and path for a non-GitHub.com site" do
+      gitlib.remote.add('origin', 'git@myco.com:jdigger/git-process.git')
+
+      stub_post('https://tu:dfsdf@myco.com/api/v3/authorizations',
+                :send => auth_json,
+                :body => {:token => test_token})
+
+      ghc.create_authorization().should == test_token
+    end
+
+
+    it "site should raise an error if remote.origin.url not set" do
+      gitlib.config['remote.origin.url'] = ''
+
+      expect { ghc.base_github_api_url_for_remote }.to raise_error GitHubService::NoRemoteRepository
+    end
+
+
+    it "site should not work for a garbage url address" do
+      gitlib.remote.add('origin', 'garbage')
+
+      expect { ghc.base_github_api_url_for_remote }.to raise_error URI::InvalidURIError
+    end
+
+
+    it "site should work for an ssh-configured url address" do
+      gitlib.remote.add('origin', 'git@github.myco.com:fooble')
+
+      ghc.base_github_api_url_for_remote.should == 'https://github.myco.com'
+    end
+
+  end
+
+
+  it "#url_to_base_github_api_url" do
+    c = GitHubService::Configuration
+
+    c.url_to_base_github_api_url('ssh://git@github.myco.com/fooble').should == 'https://github.myco.com'
+    c.url_to_base_github_api_url('git://myco.com/jdigger/git-process.git').should == 'https://myco.com'
+    c.url_to_base_github_api_url('http://github.myco.com/fooble').should == 'http://github.myco.com'
+    c.url_to_base_github_api_url('http://tu@github.myco.com/fooble').should == 'http://github.myco.com'
+    c.url_to_base_github_api_url('https://github.myco.com/fooble').should == 'https://github.myco.com'
+    c.url_to_base_github_api_url('https://github.com/fooble').should == 'https://api.github.com'
+  end
+
+
+  def auth_json
+    JSON({:note_url => 'http://jdigger.github.com/git-process',
+          :scopes => %w(repo user gist), :note => "Git-Process"})
+  end
+
+end

data/spec/github_pull_request_spec.rb

@@ -0,0 +1,117 @@
+require 'git-process/pull_request'
+require 'GitRepoHelper'
+require 'github_test_helper'
+require 'json'
+require 'octokit'
+require 'tempfile'
+
+describe GitHub::PullRequest, :git_repo_helper do
+  include GitHubTestHelper
+
+
+  def test_token
+    'hfgkdjfgksjhdfkls'
+  end
+
+
+  def pull_request
+    @pr ||= GitHub::PullRequest.new(gitlib, 'test_remote', 'test_repo', :user => 'test_user')
+  end
+
+
+  before(:each) do
+    gitlib.config['gitProcess.github.authToken'] = test_token
+    gitlib.remote.add('test_remote', 'git@github.com:test_repo.git')
+  end
+
+
+  describe '#create' do
+
+    it 'should return a pull request for a good request' do
+      stub_post('https://api.github.com/repos/test_repo/pulls', :body => {:number => 1, :state => 'open'})
+
+      pull_request.create('test_base', 'test_head', 'test title', 'test body')[:state].should == 'open'
+    end
+
+
+    it 'should handle asking for a duplicate pull request' do
+      # trying to create the request should return "HTTP 422: Unprocessable Entity" because it already exists
+      stub_post('https://api.github.com/repos/test_repo/pulls', :status => 422)
+
+      # listing all existing pull requests should contain the current branch
+      stub_get('https://api.github.com/repos/test_repo/pulls?state=open', :status => 200,
+               :body => [{:html_url => 'test_url', :head => {:ref => 'test_head'}, :base => {:ref => 'test_base'}}])
+
+      pull_request.create('test_base', 'test_head', 'test title', 'test body')[:html_url].should == 'test_url'
+    end
+
+  end
+
+
+  describe 'get' do
+
+    it 'should return a pull request for a good request' do
+      stub_get('https://api.github.com/repos/test_repo/pulls/1', :body => {:number => 1, :state => 'open'})
+
+      pull_request.pull_request(1)[:state].should == 'open'
+    end
+
+  end
+
+
+  describe '#close' do
+
+    it 'should close a good current pull request' do
+      stub_get('https://api.github.com/repos/test_repo/pulls?state=open', :body => [
+          {:number => 1, :state => 'open', :html_url => 'test_url', :head => {:ref => 'test_head'},
+           :base => {:ref => 'test_base'}}])
+      stub_patch('https://api.github.com/repos/test_repo/pulls/1', :send => JSON({:state => 'closed'}),
+                 :body => {:number => 1, :state => 'closed', :html_url => 'test_url', :head => {:ref => 'test_head'},
+                           :base => {:ref => 'test_base'}})
+
+      pull_request.close('test_base', 'test_head')[:state].should == 'closed'
+    end
+
+
+    it 'should close a good current pull request using the pull request number' do
+      stub_patch('https://api.github.com/repos/test_repo/pulls/1', :send => JSON({:state => 'closed'}),
+                 :body => {:number => 1, :state => 'closed', :html_url => 'test_url',
+                           :head => {:ref => 'test_head'}, :base => {:ref => 'test_base'}})
+
+      pull_request.close(1)[:state].should == 'closed'
+    end
+
+
+    it 'should retry closing a good current pull request when getting a 422' do
+      stub = stub_request(:patch, 'https://api.github.com/repos/test_repo/pulls/1')
+
+      stub.with(:body => JSON({:state => 'closed'}))
+
+      stub.to_raise(Octokit::UnprocessableEntity.new).then.
+          to_raise(Octokit::UnprocessableEntity.new).then.
+          to_raise(Octokit::UnprocessableEntity.new).then.
+          to_raise(Octokit::UnprocessableEntity.new).then.
+          to_return(:status => 200, :body => {:number => 1, :state => 'closed', :html_url => 'test_url',
+                           :head => {:ref => 'test_head'}, :base => {:ref => 'test_base'}})
+
+      pull_request.close(1)[:state].should == 'closed'
+    end
+
+
+    it 'should complain about a missing pull request' do
+      stub_get('https://api.github.com/repos/test_repo/pulls?state=open', :body => [
+          {:number => 1, :state => 'open', :html_url => 'test_url', :head => {:ref => 'test_head'},
+           :base => {:ref => 'test_base'}}])
+
+      expect { pull_request.close('test_base', 'missing_head') }.to raise_error GitHub::PullRequest::NotFoundError
+    end
+
+
+    it 'should complain about wrong number of arguments' do
+      expect { pull_request.close() }.to raise_error ::ArgumentError
+      expect { pull_request.close('1', '2', '3') }.to raise_error ::ArgumentError
+    end
+
+  end
+
+end

data/spec/github_test_helper.rb

@@ -0,0 +1,49 @@
+require 'FileHelpers'
+require 'git-process/git_process'
+require 'webmock/rspec'
+
+module GitHubTestHelper
+
+
+  def stub_get(url, opts = {})
+    stub = stub_request(:get, url)
+
+    if opts[:token]
+      stub.with(:Authorization => "token #{opts[:token]}")
+    end
+
+    stub.to_return(:status => opts[:status] ? opts[:status] : 200, :body => opts[:body] ? opts[:body] : '')
+    stub
+  end
+
+
+  def stub_post(url, opts = {})
+    stub = stub_request(:post, url)
+
+    if opts[:token]
+      stub.with(:Authorization => "token #{opts[:token]}")
+    end
+
+    stub.to_return(:status => opts[:status] ? opts[:status] : 200, :body => opts[:body] ? opts[:body] : '')
+
+    stub
+  end
+
+
+  def stub_patch(url, opts = {})
+    stub = stub_request(:patch, url)
+
+    if opts[:token]
+      stub.with(:Authorization => "token #{opts[:token]}")
+    end
+
+    if opts[:send]
+      stub.with(:body => opts[:send])
+    end
+
+    stub.to_return(:status => opts[:status] ? opts[:status] : 200, :body => opts[:body] ? opts[:body] : '')
+
+    stub
+  end
+
+end

data/spec/new_fb_spec.rb

@@ -0,0 +1,126 @@
+require 'git-process/new_fb'
+require 'GitRepoHelper'
+include GitProc
+
+
+describe NewFeatureBranch do
+  include GitRepoHelper
+
+  before(:each) do
+    create_files(%w(.gitignore))
+    gitlib.commit('initial')
+  end
+
+
+  after(:each) do
+    rm_rf(gitlib.workdir)
+  end
+
+
+  def create_process(dir, opts = {})
+    opts[:branch_name] = 'test_branch'
+    NewFeatureBranch.new(dir, opts)
+  end
+
+
+  def log_level
+    Logger::ERROR
+  end
+
+
+  it 'should create the named branch against origin/master' do
+    clone_repo do |gl|
+      gp = create_process(gl)
+      gl.checkout('other_branch', :new_branch => 'master')
+      change_file_and_commit('a', '', gl)
+      change_file_and_commit('b', '', gl)
+      new_branch = gp.runner
+
+      new_branch.name.should == 'test_branch'
+      new_branch.sha.should == gl.branches['origin/master'].sha
+    end
+  end
+
+
+  it "should bring committed changes on _parking_ over to the new branch" do
+    clone_repo do |gl|
+      gl.checkout('_parking_', :new_branch => 'master')
+      change_file_and_commit('a', '', gl)
+      change_file_and_commit('b', '', gl)
+
+      gp = create_process(gl)
+      new_branch = gp.runner
+
+      new_branch.name.should == 'test_branch'
+      Dir.chdir(gl.workdir) do |_|
+        File.exists?('a').should be_true
+        File.exists?('b').should be_true
+      end
+
+      gl.config["branch.test_branch.remote"].should == 'origin'
+      gl.config["branch.test_branch.merge"].should == 'refs/heads/master'
+
+      gl.fetch
+      gl.branches.parking.should be_nil
+      new_branch.sha.should_not == gl.branches['origin/master'].sha
+    end
+
+  end
+
+
+  it "should move new branch over to the integration branch" do
+    clone_repo do |gl|
+      gl.checkout('_parking_', :new_branch => 'master')
+      change_file_and_commit('a', '', gitlib)
+      change_file_and_commit('b', '', gitlib)
+
+      gl.fetch
+      gp = create_process(gl)
+      new_branch = gp.runner
+
+      new_branch.name.should == 'test_branch'
+      Dir.chdir(gitlib.workdir) do |_|
+        File.exists?('a').should be_true
+        File.exists?('b').should be_true
+      end
+
+      gl.config["branch.test_branch.remote"].should == 'origin'
+      gl.config["branch.test_branch.merge"].should == 'refs/heads/master'
+
+      gl.fetch
+      gl.branches.parking.should be_nil
+      new_branch.sha.should == gl.branches['origin/master'].sha
+    end
+
+  end
+
+
+  it "should use 'integration_branch' instead of 'remote_master_branch'" do
+    change_file_and_commit('a', '')
+
+    new_branch = gitprocess.runner
+
+    new_branch.name.should == 'test_branch'
+  end
+
+
+  it "should bring new/uncommitted changes on _parking_ over to the new branch" do
+    gitlib.branch('origin/master', :base_branch => 'master')
+    gitlib.checkout('_parking_', :new_branch => 'master')
+    change_file_and_commit('a', '')
+    change_file_and_add('b', '')
+    change_file('c', '')
+
+    new_branch = gitprocess.runner
+
+    new_branch.name.should == 'test_branch'
+    Dir.chdir(gitlib.workdir) do |_|
+      File.exists?('a').should be_true
+      File.exists?('b').should be_true
+      File.exists?('c').should be_true
+    end
+
+    gitlib.branches.parking.should be_nil
+  end
+
+end

data/spec/pull_request_helper.rb

@@ -0,0 +1,94 @@
+module PullRequestHelper
+
+  def create_pull_request(opts = {})
+    v = {
+        :head_remote => 'testrepo',
+        :head_repo => 'test_repo',
+        :base_repo => 'test_repo',
+        :head_branch => 'test_branch',
+        :base_branch => 'source_branch',
+        :api_url => 'https://api.github.com',
+        :pr_number => '32',
+        :state => 'open',
+    }
+    v.merge! opts
+    v[:ssh_head_url] = "git@github.com:#{opts[:head_repo] || v[:head_repo]}.git" unless opts.has_key?(:ssh_head_url)
+    v[:ssh_base_url] = "git@github.com:#{opts[:base_repo] || v[:base_repo]}.git" unless opts.has_key?(:ssh_base_url)
+    PullRequestHelper::_basic_pull_request_data(v)
+  end
+
+
+  def self._basic_pull_request_data(opts = {})
+    {
+        :number => opts[:pr_number],
+        :state => opts[:state],
+        :head => {
+            :remote => opts[:head_repo], # pseudo-property for testing
+            :ref => opts[:head_branch],
+            :repo => {
+                :name => opts[:head_repo],
+                :ssh_url => opts[:ssh_head_url],
+            }
+        },
+        :base => {
+            :remote => opts[:base_repo], # pseudo-property for testing
+            :ref => opts[:base_branch],
+            :repo => {
+                :name => opts[:base_repo],
+                :ssh_url => opts[:ssh_base_url],
+            }
+        }
+    }
+  end
+
+
+  # @abstract the Hash/JSON of the pull request structure to use
+  # @return [Hash]
+  def pull_request
+    raise NotImplementedError
+  end
+
+
+  def api_url(remote_name, glib = gitlib)
+    GitHubService::Configuration.new(glib.config, :remote_name => remote_name).base_github_api_url_for_remote
+  end
+
+
+  def stub_get_pull_request(pr, glib = gitlib)
+    api_url = api_url(pr[:head][:remote], glib)
+    stub_get("#{api_url}/repos/#{pr[:head][:repo][:name]}/pulls/#{pr[:number]}", :body => pr)
+  end
+
+
+  def stub_fetch(which_remote, glib = gitlib)
+    rem = pull_request[which_remote][:remote]
+    glib.stub(:fetch).with(rem)
+  end
+
+
+  #
+  # Adds a remote to git's configuration based on {#pull_request}
+  #
+  # @param [:head, :base] which_remote
+  #
+  def add_remote(which_remote, glib = gitlib)
+    glib.remote.add(pull_request[which_remote][:remote], pull_request[which_remote][:repo][:ssh_url])
+  end
+
+
+  # Verifies the branch is checked out from the HEAD branch of the pull
+  #   request and created by the same name
+  def expect_checkout_pr_head(glib = gitlib)
+    pr = pull_request
+    glib.should_receive(:checkout).with(pr[:head][:ref], :new_branch => "#{pr[:head][:remote]}/#{pr[:head][:ref]}")
+  end
+
+
+  # Verifies the tracking for the new branch is set to the BASE branch
+  #   of the pull request
+  def expect_upstream_set(glib = gitlib)
+    pr = pull_request
+    glib.should_receive(:branch).with(pr[:head][:ref], :upstream => "#{pr[:base][:remote]}/#{pr[:base][:ref]}")
+  end
+
+end