coveralls_reborn 0.8.21

data/lib/coveralls/output.rb

@@ -0,0 +1,114 @@
+module Coveralls
+  #
+  # Public: Methods for formatting strings with Term::ANSIColor.
+  # Does not utilize monkey-patching and should play nicely when
+  # included with other libraries.
+  #
+  # All methods are module methods and should be called on
+  # the Coveralls::Output module.
+  #
+  # Examples
+  #
+  #   Coveralls::Output.format("Hello World", :color => "cyan")
+  #   # => "\e[36mHello World\e[0m"
+  #
+  #   Coveralls::Output.print("Hello World")
+  #   # Hello World => nil
+  #
+  #   Coveralls::Output.puts("Hello World", :color => "underline")
+  #   # Hello World
+  #   # => nil
+  #
+  # To silence output completely:
+  #
+  #   Coveralls::Output.silent = true
+  #
+  # or set this environment variable:
+  #
+  #   COVERALLS_SILENT
+  #
+  # To disable color completely:
+  #
+  #   Coveralls::Output.no_color = true
+
+  module Output
+    attr_accessor :silent, :no_color
+    attr_writer :output
+    extend self
+
+    def output
+      (defined?(@output) && @output) || $stdout
+    end
+
+    def no_color?
+      (defined?(@no_color)) && @no_color
+    end
+
+    # Public: Formats the given string with the specified color
+    # through Term::ANSIColor
+    #
+    # string  - the text to be formatted
+    # options - The hash of options used for formatting the text:
+    #           :color - The color to be passed as a method to
+    #                    Term::ANSIColor
+    #
+    # Examples
+    #
+    #   Coveralls::Output.format("Hello World!", :color => "cyan")
+    #   # => "\e[36mHello World\e[0m"
+    #
+    # Returns the formatted string.
+    def format(string, options = {})
+      unless no_color?
+        require 'term/ansicolor'
+        if options[:color]
+          options[:color].split(/\s/).reverse_each do |color|
+            if Term::ANSIColor.respond_to?(color.to_sym)
+              string = Term::ANSIColor.send(color.to_sym, string)
+            end
+          end
+        end
+      end
+      string
+    end
+
+    # Public: Passes .format to Kernel#puts
+    #
+    # string  - the text to be formatted
+    # options - The hash of options used for formatting the text:
+    #           :color - The color to be passed as a method to
+    #                    Term::ANSIColor
+    #
+    #
+    # Example
+    #
+    #   Coveralls::Output.puts("Hello World", :color => "cyan")
+    #
+    # Returns nil.
+    def puts(string, options = {})
+      return if silent?
+      (options[:output] || output).puts self.format(string, options)
+    end
+
+    # Public: Passes .format to Kernel#print
+    #
+    # string  - the text to be formatted
+    # options - The hash of options used for formatting the text:
+    #           :color - The color to be passed as a method to
+    #                    Term::ANSIColor
+    #
+    # Example
+    #
+    #   Coveralls::Output.print("Hello World!", :color => "underline")
+    #
+    # Returns nil.
+    def print(string, options = {})
+      return if silent?
+      (options[:output] || output).print self.format(string, options)
+    end
+
+    def silent?
+      ENV["COVERALLS_SILENT"] || (defined?(@silent) && @silent)
+    end
+  end
+end

data/lib/coveralls/rake/task.rb

@@ -0,0 +1,19 @@
+require 'rake'
+require 'rake/tasklib'
+
+module Coveralls
+  class RakeTask < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+
+    def initialize(*args, &task_block)
+      namespace :coveralls do
+        desc "Push latest coverage results to Coveralls.io"
+        task :push do
+          require 'coveralls'
+          Coveralls.push!
+        end
+      end
+    end # initialize
+
+  end # class
+end # module

data/lib/coveralls/simplecov.rb

@@ -0,0 +1,101 @@
+module Coveralls
+  module SimpleCov
+    class Formatter
+
+      def display_result(result)
+        # Log which files would be submitted.
+        if result.files.length > 0
+          Coveralls::Output.puts "[Coveralls] Some handy coverage stats:"
+        else
+          Coveralls::Output.puts "[Coveralls] There are no covered files.", color: "yellow"
+        end
+        result.files.each do |f|
+          Coveralls::Output.print "  * "
+          Coveralls::Output.print short_filename(f.filename).to_s, color: "cyan"
+          Coveralls::Output.print " => ", color: "white"
+          cov = "#{f.covered_percent.round}%"
+          if f.covered_percent > 90
+            Coveralls::Output.print cov, color: "green"
+          elsif f.covered_percent > 80
+            Coveralls::Output.print cov, color: "yellow"
+          else
+            Coveralls::Output.print cov, color: "red"
+          end
+          Coveralls::Output.puts ""
+        end
+        true
+      end
+
+      def get_source_files(result)
+        # Gather the source files.
+        source_files = []
+        result.files.each do |file|
+          properties = {}
+
+          # Get Source
+          properties[:source] = File.open(file.filename, "rb:utf-8").read
+
+          # Get the root-relative filename
+          properties[:name] = short_filename(file.filename)
+
+          # Get the coverage
+          properties[:coverage] = file.coverage.dup
+
+          # Skip nocov lines
+          file.lines.each_with_index do |line, i|
+            properties[:coverage][i] = nil if line.skipped?
+          end
+
+          source_files << properties
+        end
+        source_files
+      end
+
+      def format(result)
+
+        unless Coveralls.should_run?
+          if Coveralls.noisy?
+            display_result result
+          end
+          return
+        end
+
+        # Post to Coveralls.
+        API.post_json "jobs", 
+          source_files: get_source_files(result),
+          test_framework: result.command_name.downcase,
+          run_at: result.created_at
+
+        Coveralls::Output.puts output_message result
+
+        true
+
+      rescue Exception => e
+        display_error e
+      end
+
+      def display_error(e)
+        Coveralls::Output.puts "Coveralls encountered an exception:", color: "red"
+        Coveralls::Output.puts e.class.to_s, color: "red"
+        Coveralls::Output.puts e.message, color: "red"
+        e.backtrace.each do |line|
+          Coveralls::Output.puts line, color: "red"
+        end if e.backtrace
+        if e.respond_to?(:response) && e.response
+          Coveralls::Output.puts e.response.to_s, color: "red"
+        end
+        false
+      end
+
+      def output_message(result)
+        "Coverage is at #{result.covered_percent.round(2) rescue result.covered_percent.round}%.\nCoverage report sent to Coveralls."
+      end
+
+      def short_filename(filename)
+        filename = filename.gsub(::SimpleCov.root, '.').gsub(/^\.\//, '') if ::SimpleCov.root
+        filename
+      end
+
+    end
+  end
+end

data/lib/coveralls/version.rb

@@ -0,0 +1,3 @@
+module Coveralls
+ VERSION = "0.8.21"
+end

data/lib/coveralls.rb

@@ -0,0 +1,101 @@
+require "coveralls/version"
+require "coveralls/configuration"
+require "coveralls/api"
+require "coveralls/output"
+require "coveralls/simplecov"
+
+module Coveralls
+  extend self
+
+  class NilFormatter
+    def format(result)
+    end
+  end
+
+  attr_accessor :testing, :noisy, :run_locally
+
+  def wear!(simplecov_setting=nil, &block)
+    setup!
+    start! simplecov_setting, &block
+  end
+
+  def wear_merged!(simplecov_setting=nil, &block)
+    require 'simplecov'
+    @@adapter = :simplecov
+    ::SimpleCov.formatter = NilFormatter
+    start! simplecov_setting, &block
+  end
+
+  def push!
+    require 'simplecov'
+    result = ::SimpleCov::ResultMerger.merged_result
+    Coveralls::SimpleCov::Formatter.new.format result
+  end
+
+  def setup!
+    # Try to load up SimpleCov.
+    @@adapter = nil
+    if defined?(::SimpleCov)
+      @@adapter = :simplecov
+    else
+      begin
+        require 'simplecov'
+        @@adapter = :simplecov if defined?(::SimpleCov)
+      rescue
+      end
+    end
+
+    # Load the appropriate adapter.
+    if @@adapter == :simplecov
+      ::SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+      Coveralls::Output.puts("[Coveralls] Set up the SimpleCov formatter.", color: "green")
+    else
+      Coveralls::Output.puts("[Coveralls] Couldn't find an appropriate adapter.", color: "red")
+    end
+
+  end
+
+  def start!(simplecov_setting = 'test_frameworks', &block)
+    if @@adapter == :simplecov
+      ::SimpleCov.add_filter 'vendor'
+
+      if simplecov_setting
+        Coveralls::Output.puts("[Coveralls] Using SimpleCov's '#{simplecov_setting}' settings.", color: "green")
+        if block_given?
+          ::SimpleCov.start(simplecov_setting) { instance_eval(&block)}
+        else
+          ::SimpleCov.start(simplecov_setting)
+        end
+      elsif block
+        Coveralls::Output.puts("[Coveralls] Using SimpleCov settings defined in block.", color: "green")
+        ::SimpleCov.start { instance_eval(&block) }
+      else
+        Coveralls::Output.puts("[Coveralls] Using SimpleCov's default settings.", color: "green")
+        ::SimpleCov.start
+      end
+    end
+  end
+
+  def should_run?
+    # Fail early if we're not on a CI
+    unless will_run?
+      Coveralls::Output.puts("[Coveralls] Outside the CI environment, not sending data.", color: "yellow")
+      return false
+    end
+
+    if ENV["COVERALLS_RUN_LOCALLY"] || (defined?(@run_locally) && @run_locally)
+      Coveralls::Output.puts("[Coveralls] Creating a new job on Coveralls from local coverage results.", color: "cyan")
+    end
+
+    true
+  end
+
+  def will_run?
+    ENV["CI"] || ENV["JENKINS_URL"] || ENV['TDDIUM'] ||
+      ENV["COVERALLS_RUN_LOCALLY"] || (defined?(@testing) && @testing)
+  end
+
+  def noisy?
+    ENV["COVERALLS_NOISY"] || (defined?(@noisy) && @noisy)
+  end
+end

data/spec/coveralls/configuration_spec.rb

@@ -0,0 +1,355 @@
+require 'spec_helper'
+
+describe Coveralls::Configuration do
+  before do
+    ENV.stub(:[]).and_return(nil)
+  end
+
+  describe '.configuration' do
+    it "returns a hash with the default keys" do
+      config = Coveralls::Configuration.configuration
+      config.should be_a(Hash)
+      config.keys.should include(:environment)
+      config.keys.should include(:git)
+    end
+
+    context 'yaml_config' do
+      let(:repo_token) { SecureRandom.hex(4) }
+      let(:repo_secret_token) { SecureRandom.hex(4) }
+      let(:yaml_config) {
+        {
+          'repo_token' => repo_token,
+          'repo_secret_token' => repo_secret_token
+        }
+      }
+
+      before do
+        Coveralls::Configuration.stub(:yaml_config).and_return(yaml_config)
+      end
+
+      it 'sets the Yaml config and associated variables if present' do
+        config = Coveralls::Configuration.configuration
+        config[:configuration].should eq(yaml_config)
+        config[:repo_token].should eq(repo_token)
+      end
+
+      it 'uses the repo_secret_token if the repo_token is not set' do
+        yaml_config.delete('repo_token')
+        config = Coveralls::Configuration.configuration
+        config[:configuration].should eq(yaml_config)
+        config[:repo_token].should eq(repo_secret_token)
+      end
+    end
+
+    context 'repo_token in environment' do
+      let(:repo_token) { SecureRandom.hex(4) }
+
+      before do
+        ENV.stub(:[]).with('COVERALLS_REPO_TOKEN').and_return(repo_token)
+      end
+
+      it 'pulls the repo token from the environment if set' do
+        config = Coveralls::Configuration.configuration
+        config[:repo_token].should eq(repo_token)
+      end
+    end
+
+    context 'Services' do
+      context 'with env based service name' do
+        let(:service_name) { 'travis-enterprise' }
+        before do
+          ENV.stub(:[]).with('TRAVIS').and_return('1')
+          ENV.stub(:[]).with('COVERALLS_SERVICE_NAME').and_return(service_name)
+        end
+
+        it 'pulls the service name from the environment if set' do
+          config = Coveralls::Configuration.configuration
+          config[:service_name].should eq(service_name)
+        end
+      end
+
+      context 'on Travis' do
+        before do
+          ENV.stub(:[]).with('TRAVIS').and_return('1')
+        end
+
+        it 'should set service parameters for this service and no other' do
+          Coveralls::Configuration.should_receive(:set_service_params_for_travis).with(anything, anything)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_circleci)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_semaphore)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_jenkins)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_coveralls_local)
+          Coveralls::Configuration.should_receive(:set_standard_service_params_for_generic_ci)
+          Coveralls::Configuration.configuration
+        end
+      end
+
+      context 'on CircleCI' do
+        before do
+          ENV.stub(:[]).with('CIRCLECI').and_return('1')
+        end
+
+        it 'should set service parameters for this service and no other' do
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_travis)
+          Coveralls::Configuration.should_receive(:set_service_params_for_circleci)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_semaphore)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_jenkins)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_coveralls_local)
+          Coveralls::Configuration.should_receive(:set_standard_service_params_for_generic_ci)
+          Coveralls::Configuration.configuration
+        end
+      end
+
+      context 'on Semaphore' do
+        before do
+          ENV.stub(:[]).with('SEMAPHORE').and_return('1')
+        end
+
+        it 'should set service parameters for this service and no other' do
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_travis)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_circleci)
+          Coveralls::Configuration.should_receive(:set_service_params_for_semaphore)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_jenkins)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_coveralls_local)
+          Coveralls::Configuration.should_receive(:set_standard_service_params_for_generic_ci)
+          Coveralls::Configuration.configuration
+        end
+      end
+
+      context 'when using Jenkins' do
+        before do
+          ENV.stub(:[]).with('JENKINS_URL').and_return('1')
+        end
+
+        it 'should set service parameters for this service and no other' do
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_travis)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_circleci)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_semaphore)
+          Coveralls::Configuration.should_receive(:set_service_params_for_jenkins)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_coveralls_local)
+          Coveralls::Configuration.should_receive(:set_standard_service_params_for_generic_ci)
+          Coveralls::Configuration.configuration
+        end
+      end
+
+      context 'when running Coveralls locally' do
+        before do
+          ENV.stub(:[]).with('COVERALLS_RUN_LOCALLY').and_return('1')
+        end
+
+        it 'should set service parameters for this service and no other' do
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_travis)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_circleci)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_semaphore)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_jenkins)
+          Coveralls::Configuration.should_receive(:set_service_params_for_coveralls_local)
+          Coveralls::Configuration.should_receive(:set_standard_service_params_for_generic_ci)
+          Coveralls::Configuration.configuration
+        end
+      end
+
+      context 'for generic CI' do
+        before do
+          ENV.stub(:[]).with('CI_NAME').and_return('1')
+        end
+
+        it 'should set service parameters for this service and no other' do
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_travis)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_circleci)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_semaphore)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_jenkins)
+          Coveralls::Configuration.should_not_receive(:set_service_params_for_coveralls_local)
+          Coveralls::Configuration.should_receive(:set_standard_service_params_for_generic_ci).with(anything)
+          Coveralls::Configuration.configuration
+        end
+      end
+    end
+  end
+
+  describe '.set_service_params_for_travis' do
+    let(:travis_job_id) { SecureRandom.hex(4) }
+    before do
+      ENV.stub(:[]).with('TRAVIS_JOB_ID').and_return(travis_job_id)
+    end
+
+    it 'should set the service_job_id' do
+      config = {}
+      Coveralls::Configuration.set_service_params_for_travis(config, nil)
+      config[:service_job_id].should eq(travis_job_id)
+    end
+
+    it 'should set the service_name to travis-ci by default' do
+      config = {}
+      Coveralls::Configuration.set_service_params_for_travis(config, nil)
+      config[:service_name].should eq('travis-ci')
+    end
+
+    it 'should set the service_name to a value if one is passed in' do
+      config = {}
+      random_name = SecureRandom.hex(4)
+      Coveralls::Configuration.set_service_params_for_travis(config, random_name)
+      config[:service_name].should eq(random_name)
+    end
+  end
+
+  describe '.set_service_params_for_circleci' do
+    let(:circle_build_num) { SecureRandom.hex(4) }
+    before do
+      ENV.stub(:[]).with('CIRCLE_BUILD_NUM').and_return(circle_build_num)
+    end
+
+    it 'should set the expected parameters' do
+      config = {}
+      Coveralls::Configuration.set_service_params_for_circleci(config)
+      config[:service_name].should eq('circleci')
+      config[:service_number].should eq(circle_build_num)
+    end
+  end
+
+  describe '.set_service_params_for_gitlab' do
+    let(:commit_sha) { SecureRandom.hex(32) }
+    let(:service_job_number) { "spec:one" }
+    let(:service_job_id) { 1234 }
+    let(:service_branch) { "feature" }
+
+    before do
+      ENV.stub(:[]).with('CI_BUILD_NAME').and_return(service_job_number)
+      ENV.stub(:[]).with('CI_BUILD_ID').and_return(service_job_id)
+      ENV.stub(:[]).with('CI_BUILD_REF_NAME').and_return(service_branch)
+      ENV.stub(:[]).with('CI_BUILD_REF').and_return(commit_sha)
+    end
+
+    it 'should set the expected parameters' do
+      config = {}
+      Coveralls::Configuration.set_service_params_for_gitlab(config)
+      config[:service_name].should eq('gitlab-ci')
+      config[:service_job_number].should eq(service_job_number)
+      config[:service_job_id].should eq(service_job_id)
+      config[:service_branch].should eq(service_branch)
+      config[:commit_sha].should eq(commit_sha)
+    end
+  end
+
+  describe '.set_service_params_for_semaphore' do
+    let(:semaphore_build_num) { SecureRandom.hex(4) }
+    before do
+      ENV.stub(:[]).with('SEMAPHORE_BUILD_NUMBER').and_return(semaphore_build_num)
+    end
+
+    it 'should set the expected parameters' do
+      config = {}
+      Coveralls::Configuration.set_service_params_for_semaphore(config)
+      config[:service_name].should eq('semaphore')
+      config[:service_number].should eq(semaphore_build_num)
+    end
+  end
+
+  describe '.set_service_params_for_jenkins' do
+    let(:service_pull_request) { '1234' }
+    let(:build_num) { SecureRandom.hex(4) }
+    before do
+      ENV.stub(:[]).with('CI_PULL_REQUEST').and_return(service_pull_request)
+      ENV.stub(:[]).with('BUILD_NUMBER').and_return(build_num)
+    end
+
+    it 'should set the expected parameters' do
+      config = {}
+      Coveralls::Configuration.set_service_params_for_jenkins(config)
+      Coveralls::Configuration.set_standard_service_params_for_generic_ci(config)
+      config[:service_name].should eq('jenkins')
+      config[:service_number].should eq(build_num)
+      config[:service_pull_request].should eq(service_pull_request)
+    end
+  end
+
+  describe '.set_service_params_for_coveralls_local' do
+    it 'should set the expected parameters' do
+      config = {}
+      Coveralls::Configuration.set_service_params_for_coveralls_local(config)
+      config[:service_name].should eq('coveralls-ruby')
+      config[:service_job_id].should be_nil
+      config[:service_event_type].should eq('manual')
+    end
+  end
+
+  describe '.set_service_params_for_generic_ci' do
+    let(:service_name) { SecureRandom.hex(4) }
+    let(:service_number) { SecureRandom.hex(4) }
+    let(:service_build_url) { SecureRandom.hex(4) }
+    let(:service_branch) { SecureRandom.hex(4) }
+    let(:service_pull_request) { '1234' }
+
+    before do
+      ENV.stub(:[]).with('CI_NAME').and_return(service_name)
+      ENV.stub(:[]).with('CI_BUILD_NUMBER').and_return(service_number)
+      ENV.stub(:[]).with('CI_BUILD_URL').and_return(service_build_url)
+      ENV.stub(:[]).with('CI_BRANCH').and_return(service_branch)
+      ENV.stub(:[]).with('CI_PULL_REQUEST').and_return(service_pull_request)
+    end
+
+    it 'should set the expected parameters' do
+      config = {}
+      Coveralls::Configuration.set_standard_service_params_for_generic_ci(config)
+      config[:service_name].should eq(service_name)
+      config[:service_number].should eq(service_number)
+      config[:service_build_url].should eq(service_build_url)
+      config[:service_branch].should eq(service_branch)
+      config[:service_pull_request].should eq(service_pull_request)
+    end
+  end
+
+  describe '.set_service_params_for_appveyor' do
+    let(:service_number) { SecureRandom.hex(4) }
+    let(:service_branch) { SecureRandom.hex(4) }
+    let(:commit_sha) { SecureRandom.hex(4) }
+    let(:repo_name) { SecureRandom.hex(4) }
+
+    before do
+      ENV.stub(:[]).with('APPVEYOR_BUILD_VERSION').and_return(service_number)
+      ENV.stub(:[]).with('APPVEYOR_REPO_BRANCH').and_return(service_branch)
+      ENV.stub(:[]).with('APPVEYOR_REPO_COMMIT').and_return(commit_sha)
+      ENV.stub(:[]).with('APPVEYOR_REPO_NAME').and_return(repo_name)
+    end
+
+    it 'should set the expected parameters' do
+      config = {}
+      Coveralls::Configuration.set_service_params_for_appveyor(config)
+      config[:service_name].should eq('appveyor')
+      config[:service_number].should eq(service_number)
+      config[:service_branch].should eq(service_branch)
+      config[:commit_sha].should eq(commit_sha)
+      config[:service_build_url].should eq('https://ci.appveyor.com/project/%s/build/%s' % [repo_name, service_number])
+    end
+  end
+
+  describe '.git' do
+    let(:git_id) { SecureRandom.hex(2) }
+    let(:author_name) { SecureRandom.hex(4) }
+    let(:author_email) { SecureRandom.hex(4) }
+    let(:committer_name) { SecureRandom.hex(4) }
+    let(:committer_email) { SecureRandom.hex(4) }
+    let(:message) { SecureRandom.hex(4) }
+    let(:branch) { SecureRandom.hex(4) }
+
+    before do
+      allow(ENV).to receive(:fetch).with('GIT_ID', anything).and_return(git_id)
+      allow(ENV).to receive(:fetch).with('GIT_AUTHOR_NAME', anything).and_return(author_name)
+      allow(ENV).to receive(:fetch).with('GIT_AUTHOR_EMAIL', anything).and_return(author_email)
+      allow(ENV).to receive(:fetch).with('GIT_COMMITTER_NAME', anything).and_return(committer_name)
+      allow(ENV).to receive(:fetch).with('GIT_COMMITTER_EMAIL', anything).and_return(committer_email)
+      allow(ENV).to receive(:fetch).with('GIT_MESSAGE', anything).and_return(message)
+      allow(ENV).to receive(:fetch).with('GIT_BRANCH', anything).and_return(branch)
+    end
+
+    it 'uses ENV vars' do
+      config = Coveralls::Configuration.git
+      config[:head][:id].should eq(git_id)
+      config[:head][:author_name].should eq(author_name)
+      config[:head][:author_email].should eq(author_email)
+      config[:head][:committer_name].should eq(committer_name)
+      config[:head][:committer_email].should eq(committer_email)
+      config[:head][:message].should eq(message)
+      config[:branch].should eq(branch)
+    end
+  end
+end