thegarage-gitx 1.1.0 → 1.2.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f44b6f1f0c0229d1b8f76ea3e80eda7917d765c
-  data.tar.gz: 02a85083e7efcc95bb7fab522943e02c946f1a40
+  metadata.gz: 3f48eab04a8576c7f4757294009f53818b01f3cc
+  data.tar.gz: ac2707ffbe75737ebb5fcfa8908008468803f31c
 SHA512:
-  metadata.gz: af4fe8c1a93b78ae7fd33c6ea90d78bd9e127feeec361184b47d1399dae05e3ea18033ccc45450b2377ccd7bf5a0e1ea65794f9d753a86ee1c5677e711aa4c6e
-  data.tar.gz: 704e75ec3c06cce54d8bc5c68f38f72f73bce82983ee60b2ac3b57dd2bb2dc6c8a82c6299d0174742b37f6b05df0e2107830ad03b63d4820e69d14240d8eb547
+  metadata.gz: 43d0831356ca1cafa085e85705568d2409c8ca62aa325a4bfbb63b45113c75c75333ce59bfb91d3dfd0278d90466334a45ee66d3b411f1c19d13dd890a91338f
+  data.tar.gz: e44c8876673101a8da4c5c830929ca1a58b4384bbfd53ba60392260df7330eae914312668b156182b4edf77231d2f7fcdac2a5e659b3bcfacfd3c791301d713f

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - '2.0.0'
+
+after_success:
+  - git config --global user.email "builds@travis-ci.com"
+  - git config --global user.name "Travis CI"
+  - git buildtag

data/README.md

@@ -1,5 +1,7 @@
 # thegarage-gitx
 
+[![Build Status](https://travis-ci.org/thegarage/thegarage-gitx.png?branch=fix-rspec-mocks)](https://travis-ci.org/thegarage/thegarage-gitx)
+
 Useful Git eXtensions for Development workflow at The Garage.
 
 Inspired by the [socialcast-git-extensions gem](https://github.com/socialcast/socialcast-git-extensions)
@@ -28,6 +30,7 @@ create a pull request on github for peer review of the current branch.
 ## git release
 
 release the current feature branch to master.  This operation will perform the following:
+
 * pull in latest code from remote branch
 * merge in latest code from master branch
 * prompt user to confirm they actually want to perform the release
@@ -44,6 +47,10 @@ delete released branches after they have been merged into master.
 
 reset an aggregate branch (ex: prototype, staging) back to a known good state.
 
+## git buildtag
+
+create a build tag for the current Travis-CI build and push it back to origin
+
 
 ## Note on Patches/Pull Requests
 

data/bin/git-buildtag

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'thegarage/gitx', 'cli.rb')
+Thegarage::Gitx::CLI.start (['buildtag'] + ARGV)

data/lib/thegarage/gitx/cli.rb

@@ -5,6 +5,9 @@ require 'thegarage/gitx'
 module Thegarage
   module Gitx
     class CLI < Thor
+      include Thor::Actions
+      add_runtime_options!
+
       include Thegarage::Gitx
       include Thegarage::Gitx::Git
       include Thegarage::Gitx::Github
@@ -15,6 +18,7 @@ module Thegarage
         # Link to ticket describing feature/bug (plantain, JIRA, bugzilla). Format is [title](url).
         # Brief description of the change, and how it accomplishes the task they set out to do.
       EOS
+      TAGGABLE_BRANCHES = %w(master staging)
 
       method_option :trace, :type => :boolean, :aliases => '-v'
       def initialize(*args)
@@ -136,6 +140,41 @@ module Thegarage
         integrate_branch('master', 'staging')
         cleanup
       end
+
+      desc 'buildtag', 'create a tag for the current Travis-CI build and push it back to origin'
+      def buildtag
+        travis_branch = ENV['TRAVIS_BRANCH']
+        pull_request = ENV['TRAVIS_PULL_REQUEST']
+        
+        raise "Unknown branch. ENV['TRAVIS_BRANCH'] is required." unless travis_branch
+                
+        if pull_request != 'false'
+          say "Skipping creation of tag for pull request: #{pull_request}"
+        elsif !TAGGABLE_BRANCHES.include?(travis_branch)
+          say "Cannot create build tag for branch: #{travis_branch}. Only #{TAGGABLE_BRANCHES} are supported."
+        else
+          timestamp = Time.now.utc.strftime '%Y-%m-%d-%H-%M-%S'
+          git_tag = "build-#{travis_branch}-#{timestamp}"
+          run_cmd "git tag #{git_tag} -a -m 'Generated tag from TravisCI build #{ENV['TRAVIS_BUILD_NUMBER']}'"
+          run_cmd "git push origin #{git_tag}"
+        end
+      end
+
+      private
+
+      # execute a shell command and raise an error if non-zero exit code is returned
+      # return the string output from the command
+      def run_cmd(cmd, options = {})
+        output = run(cmd, capture: true)
+        success = $CHILD_STATUS.to_i == 0
+        fail "#{cmd} failed" unless success || options[:allow_failure]
+        output
+      end
+
+      # check if --pretend or -p flag passed to CLI
+      def pretend?
+        options[:pretend]
+      end
     end
   end
 end

data/lib/thegarage/gitx/version.rb

@@ -1,5 +1,5 @@
 module Thegarage
   module Gitx
-    VERSION = '1.1.0'
+    VERSION = '1.2.0.beta1'
   end
 end

data/lib/thegarage/gitx.rb

@@ -8,18 +8,5 @@ require 'English'
 module Thegarage
   module Gitx
     BASE_BRANCH = 'master'
-
-    private
-
-    # execute a shell command and raise an error if non-zero exit code is returned
-    # return the string output from the command
-    def run_cmd(cmd, options = {})
-      say "\n$ "
-      say cmd.gsub("'", ''), :red
-      output = `#{cmd}`
-      success = $CHILD_STATUS.to_i == 0
-      raise "#{cmd} failed" unless success || options[:allow_failure]
-      output
-    end
   end
 end

data/spec/spec_helper.rb

@@ -1,36 +1,21 @@
 require 'rubygems'
 require 'bundler/setup'
-require 'rspec/mocks'
-require 'webmock/rspec'
 require 'pry'
-RSpec::Mocks::setup(Object.new)
-
+require 'webmock/rspec'
 require 'thegarage/gitx/cli'
 
-RSpec.configure do |config|
-  config.mock_with :rspec
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(__dir__, "support/**/*.rb")].each { |f| require f }
 
-  def capture_with_status(stream)
-    exit_status = 0
-    begin
-      stream = stream.to_s
-      eval "$#{stream} = StringIO.new"
-      begin
-        yield
-      rescue SystemExit => system_exit # catch any exit calls
-        exit_status = system_exit.status
-      end
-      result = eval("$#{stream}").string
-    ensure
-      eval("$#{stream} = #{stream.upcase}")
-    end
-    return result, exit_status
-  end
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
 
-  def remove_directories(*names)
-    project_dir = Pathname.new(Dir.pwd)
-    names.each do |name|
-      FileUtils.rm_rf(project_dir.join(name)) if FileTest.exists?(project_dir.join(name))
-    end
-  end
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
 end

data/spec/support/meet_expectations_matcher.rb

@@ -0,0 +1,7 @@
+# empty matcher to allow for mock expectations to fire
+RSpec::Matchers.define :meet_expectations do |expected|
+  match do |actual|
+    # do nothing
+    expect(true).to be_true
+  end
+end

data/spec/thegarage/gitx/cli_spec.rb

@@ -1,87 +1,82 @@
 require 'spec_helper'
+require 'timecop'
 
 describe Thegarage::Gitx::CLI do
-  # stub methods on cli
-  class Thegarage::Gitx::CLI
-    class << self
-      attr_accessor :stubbed_executed_commands
-    end
-    private
-    # stub out command execution and record commands for test inspection
-    def run_cmd(cmd, options={})
-      self.class.stubbed_executed_commands << cmd
-      ''
-    end
-    # stub branch to always be a known branch
-    def current_branch
-      'FOO'
-    end
-    # stub current user to always be known
-    def current_user
-      'wireframe'
-    end
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
   end
+  let(:cli) { Thegarage::Gitx::CLI.new(args, options, config) }
 
   before do
-    Thegarage::Gitx::CLI.stubbed_executed_commands = []
+    # default current branch to: feature-branch
+    allow(cli).to receive(:current_branch).and_return('feature-branch')
   end
 
+
   describe '#update' do
     before do
-      Thegarage::Gitx::CLI.start ['update']
+      expect(cli).to receive(:run).with('git pull origin feature-branch', capture: true).ordered
+      expect(cli).to receive(:run).with('git pull origin master', capture: true).ordered
+      expect(cli).to receive(:run).with('git push origin HEAD', capture: true).ordered
+
+      cli.update
     end
     it 'should run expected commands' do
-      Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-        'git pull origin FOO',
-        'git pull origin master',
-        'git push origin HEAD'
-      ]
+      should meet_expectations
     end
   end
 
   describe '#integrate' do
     context 'when target branch is ommitted' do
       before do
-        Thegarage::Gitx::CLI.start ['integrate']
+        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch -D staging", capture: true).ordered
+        expect(cli).to receive(:run).with("git fetch origin", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout staging", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull . feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout feature-branch", capture: true).ordered
+
+        cli.integrate
       end
       it 'should default to staging' do
-        Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-          "git pull origin FOO",
-          "git pull origin master",
-          "git push origin HEAD",
-          "git branch -D staging",
-          "git fetch origin",
-          "git checkout staging",
-          "git pull . FOO",
-          "git push origin HEAD",
-          "git checkout FOO",
-          "git checkout FOO"
-        ]
+        should meet_expectations
       end
     end
     context 'when target branch == prototype' do
       before do
-        Thegarage::Gitx::CLI.start ['integrate', 'prototype']
+        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch -D prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git fetch origin", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull . feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout feature-branch", capture: true).ordered
+
+        cli.integrate 'prototype'
       end
       it 'should run expected commands' do
-        Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-          "git pull origin FOO",
-          "git pull origin master",
-          "git push origin HEAD",
-          "git branch -D prototype",
-          "git fetch origin",
-          "git checkout prototype",
-          "git pull . FOO",
-          "git push origin HEAD",
-          "git checkout FOO",
-          "git checkout FOO"
-        ]
+        should meet_expectations
       end
     end
     context 'when target branch != staging || prototype' do
       it 'should raise an error' do
+        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+
         lambda {
-          Thegarage::Gitx::CLI.start ['integrate', 'asdfasdfasdf']
+          cli.integrate 'some-other-branch'
         }.should raise_error(/Only aggregate branches are allowed for integration/)
       end
     end
@@ -90,157 +85,270 @@ describe Thegarage::Gitx::CLI do
   describe '#release' do
     context 'when user rejects release' do
       before do
-        Thegarage::Gitx::CLI.any_instance.should_receive(:yes?).and_return(false)
-        Thegarage::Gitx::CLI.start ['release']
+        expect(cli).to receive(:yes?).and_return(false)
+
+        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+
+        cli.release
       end
       it 'should only run update commands' do
-        Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-          "git pull origin FOO",
-          "git pull origin master",
-          "git push origin HEAD"
-        ]
+        should meet_expectations
       end
     end
     context 'when user confirms release' do
       before do
-        Thegarage::Gitx::CLI.any_instance.should_receive(:yes?).and_return(true)
-        Thegarage::Gitx::CLI.start ['release']
+        expect(cli).to receive(:yes?).and_return(true)
+        expect(cli).to receive(:branches).and_return(%w( old-merged-feature )).twice
+
+        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull . feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch -D staging", capture: true).ordered
+        expect(cli).to receive(:run).with("git fetch origin", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout staging", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull . master", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull", capture: true).ordered
+        expect(cli).to receive(:run).with("git remote prune origin", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin --delete old-merged-feature", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch -d old-merged-feature", capture: true).ordered
+
+        cli.release
       end
       it 'should run expected commands' do
-        Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-          "git pull origin FOO",
-          "git pull origin master",
-          "git push origin HEAD",
-          "git checkout master",
-          "git pull origin master",
-          "git pull . FOO",
-          "git push origin HEAD",
-          "git branch -D staging",
-          "git fetch origin",
-          "git checkout staging",
-          "git pull . master",
-          "git push origin HEAD",
-          "git checkout master",
-          "git checkout master",
-          "git pull",
-          "git remote prune origin"
-        ]
+        should meet_expectations
       end
     end
   end
 
   describe '#nuke' do
     context 'when target branch == prototype and --destination == master' do
+      let(:options) do
+        {
+          destination: 'master'
+        }
+      end
+      let(:buildtags) do
+        %w( build-master-2013-10-01-01 ).join("\n")
+      end
       before do
-        prototype_branches = %w( dev-foo dev-bar )
-        master_branches = %w( dev-foo )
-        Thegarage::Gitx::CLI.any_instance.should_receive(:branches).and_return(prototype_branches, master_branches, prototype_branches, master_branches)
-        Thegarage::Gitx::CLI.any_instance.should_receive(:yes?).and_return(false)
-        Thegarage::Gitx::CLI.start ['nuke', 'prototype', '--destination', 'master']
+        expect(cli).to receive(:yes?).and_return(true)
+
+        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
+        expect(cli).to receive(:run).with("git tag -l 'build-master-*'", capture: true).and_return(buildtags).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch -D prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin --delete prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout -b prototype build-master-2013-10-01-01", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch --set-upstream-to origin/prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+
+        cli.nuke 'prototype'
       end
       it 'should run expected commands' do
-        Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-          "git checkout master",
-          "git branch -D prototype",
-          "git push origin --delete prototype",
-          "git checkout -b prototype build-master-2013-10-01-01",
-          "git push origin prototype",
-          "git branch --set-upstream prototype origin/prototype",
-          "git checkout master"
-        ]
+        should meet_expectations
       end
     end
     context 'when target branch == staging and --destination == staging' do
+      let(:options) do
+        {
+          destination: 'staging'
+        }
+      end
+      let(:buildtags) do
+        %w( build-staging-2013-10-02-02 ).join("\n")
+      end
       before do
-        Thegarage::Gitx::CLI.any_instance.should_receive(:yes?).and_return(false)
-        Thegarage::Gitx::CLI.start ['nuke', 'staging', '--destination', 'staging']
+        expect(cli).to receive(:yes?).and_return(true)
+
+        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
+        expect(cli).to receive(:run).with("git tag -l 'build-staging-*'", capture: true).and_return(buildtags).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch -D staging", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin --delete staging", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout -b staging build-staging-2013-10-02-02", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin staging", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch --set-upstream-to origin/staging", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+
+        cli.nuke 'staging'
       end
       it 'should run expected commands' do
-        Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-          "git checkout master",
-          "git branch -D staging",
-          "git push origin --delete staging",
-          "git checkout -b staging build-staging-2013-10-02-02",
-          "git push origin staging",
-          "git branch --set-upstream staging origin/staging",
-          "git checkout master"
-        ]
+        should meet_expectations
       end
     end
     context 'when target branch == prototype and destination prompt == nil' do
+      let(:buildtags) do
+        %w( build-prototype-2013-10-03-03 ).join("\n")
+      end
       before do
-        Thegarage::Gitx::CLI.any_instance.should_receive(:ask).and_return('')
-        Thegarage::Gitx::CLI.any_instance.should_receive(:yes?).and_return(false)
-        Thegarage::Gitx::CLI.start ['nuke', 'prototype']
+        expect(cli).to receive(:ask).and_return('')
+        expect(cli).to receive(:yes?).and_return(true)
+
+        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
+        expect(cli).to receive(:run).with("git tag -l 'build-prototype-*'", capture: true).and_return(buildtags).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch -D prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin --delete prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout -b prototype build-prototype-2013-10-03-03", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch --set-upstream-to origin/prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+
+        cli.nuke 'prototype'
       end
       it 'defaults to prototype and should run expected commands' do
-        Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-          "git checkout master",
-          "git branch -D prototype",
-          "git push origin --delete prototype",
-          "git checkout -b prototype build-prototype-2013-10-02-03",
-          "git push origin prototype",
-          "git branch --set-upstream prototype origin/prototype",
-          "git checkout master"
-        ]
+        should meet_expectations
       end
     end
     context 'when target branch == prototype and destination prompt = master' do
+      let(:buildtags) do
+        %w( build-master-2013-10-01-01 ).join("\n")
+      end
       before do
-        Thegarage::Gitx::CLI.any_instance.should_receive(:ask).and_return('master')
-        Thegarage::Gitx::CLI.any_instance.should_receive(:yes?).and_return(false)
-        Thegarage::Gitx::CLI.start ['nuke', 'prototype']
+        expect(cli).to receive(:ask).and_return('master')
+        expect(cli).to receive(:yes?).and_return(true)
+
+        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
+        expect(cli).to receive(:run).with("git tag -l 'build-master-*'", capture: true).and_return(buildtags).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch -D prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin --delete prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout -b prototype build-master-2013-10-01-01", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git branch --set-upstream-to origin/prototype", capture: true).ordered
+        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+
+        cli.nuke 'prototype'
       end
       it 'should run expected commands' do
-        Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-          "git checkout master",
-          "git branch -D prototype",
-          "git push origin --delete prototype",
-          "git checkout -b prototype build-master-2013-10-01-01",
-          "git push origin prototype",
-          "git branch --set-upstream prototype origin/prototype",
-          "git checkout master"
-        ]
+        should meet_expectations
       end
     end
     context 'when target branch != staging || prototype' do
       it 'should raise error' do
         lambda {
-          Thegarage::Gitx::CLI.any_instance.should_receive(:ask).and_return('master')
-          Thegarage::Gitx::CLI.any_instance.should_receive(:yes?).and_return(false)
-          Thegarage::Gitx::CLI.start ['nuke', 'asdfasdf']
+          expect(cli).to receive(:ask).and_return('master')
+          expect(cli).to receive(:yes?).and_return(true)
+          cli.nuke 'not-an-integration-branch'
         }.should raise_error /Only aggregate branches are allowed to be reset/
       end
     end
     context 'when user does not confirm nuking the target branch' do
+      let(:buildtags) do
+        %w( build-master-2013-10-01-01 ).join("\n")
+      end
       before do
-        Thegarage::Gitx::CLI.any_instance.should_receive(:ask).and_return('master')
-        Thegarage::Gitx::CLI.any_instance.should_receive(:yes?).and_return(false)
-        Thegarage::Gitx::CLI.start ['nuke', 'prototype']
+        expect(cli).to receive(:ask).and_return('master')
+        expect(cli).to receive(:yes?).and_return(false)
+
+        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
+        expect(cli).to receive(:run).with("git tag -l 'build-master-*'", capture: true).and_return(buildtags).ordered
+
+        cli.nuke 'prototype'
       end
       it 'should run expected commands' do
-        Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-          "git fetch --tags"
-        ]
+        should meet_expectations
+      end
+    end
+    context 'when no known good build tag found' do
+      let(:buildtags) do
+        ''
+      end
+      it 'raises error' do
+        expect(cli).to receive(:ask).and_return('master')
+
+        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
+        expect(cli).to receive(:run).with("git tag -l 'build-master-*'", capture: true).and_return(buildtags).ordered
+
+        expect { cli.nuke('prototype') }.to raise_error /No known good tag found for branch/
       end
     end
   end
 
   describe '#reviewrequest' do
-    context 'when description != null' do
+    context 'when description != null and there is an existing authorization_token' do
+      let(:options) { {description: 'testing'} }
+      let(:authorization_token) { '123981239123' }
       before do
         stub_request(:post, "https://api.github.com/repos/thegarage/thegarage-gitx/pulls").
           to_return(:status => 200, :body => %q({"html_url": "http://github.com/repo/project/pulls/1"}), :headers => {})
 
-        Thegarage::Gitx::CLI.start ['reviewrequest', '--description', 'testing']
+        expect(cli).to receive(:authorization_token).and_return(authorization_token)
+
+        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
+        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
+        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+
+        cli.reviewrequest
+      end
+      it 'should create github pull request' do
+        should meet_expectations
       end
-      it 'should create github pull request' do end # see expectations
       it 'should run expected commands' do
-        Thegarage::Gitx::CLI.stubbed_executed_commands.should == [
-          "git pull origin FOO",
-          "git pull origin master",
-          "git push origin HEAD"
-        ]
+        should meet_expectations
+      end
+    end
+  end
+
+  describe '#buildtag' do
+    let(:env_travis_branch) { nil }
+    let(:env_travis_pull_request) { nil }
+    let(:env_travis_build_number) { nil }
+    before do
+      ENV['TRAVIS_BRANCH'] = env_travis_branch
+      ENV['TRAVIS_PULL_REQUEST'] = env_travis_pull_request
+      ENV['TRAVIS_BUILD_NUMBER'] = env_travis_build_number
+    end
+    context 'when ENV[\'TRAVIS_BRANCH\'] is nil' do
+      it 'should raise Unknown Branch error' do
+        expect { cli.buildtag }.to raise_error "Unknown branch. ENV['TRAVIS_BRANCH'] is required."
+      end
+    end
+    context 'when the travis branch is master and the travis pull request is not false' do
+      let(:env_travis_branch) { 'master' }
+      let(:env_travis_pull_request) { '45' }
+      before do
+        expect(cli).to receive(:say).with("Skipping creation of tag for pull request: #{ENV['TRAVIS_PULL_REQUEST']}")
+        cli.buildtag
+      end
+      it 'tells us that it is skipping the creation of the tag' do
+        should meet_expectations
+      end
+    end
+    context 'when the travis branch is NOT master and is not a pull request' do
+      let(:env_travis_branch) { 'random-branch' }
+      let(:env_travis_pull_request) { 'false' }
+      before do
+        expect(cli).to receive(:say).with(/Cannot create build tag for branch: #{ENV['TRAVIS_BRANCH']}/)
+        cli.buildtag
+      end
+      it 'tells us that the branch is not supported' do
+        should meet_expectations
+      end
+    end
+    context 'when the travis branch is master and not a pull request' do
+      let(:env_travis_branch) { 'master' }
+      let(:env_travis_pull_request) { 'false' }
+      let(:env_travis_build_number) { '24' }
+      before do
+        Timecop.freeze(Time.utc(2013, 10, 30, 10, 21, 28)) do
+          expect(cli).to receive(:run).with("git tag build-master-2013-10-30-10-21-28 -a -m 'Generated tag from TravisCI build 24'", capture: true).ordered
+          expect(cli).to receive(:run).with("git push origin build-master-2013-10-30-10-21-28", capture: true).ordered
+          cli.buildtag
+        end
+      end
+      it 'should create a tag for the branch and push it to github' do
+        should meet_expectations
       end
     end
   end

data/thegarage-gitx.gemspec

@@ -27,4 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", '>= 2.11.0'
   spec.add_development_dependency "pry", '>= 0'
   spec.add_development_dependency "webmock", '>= 0'
+  spec.add_development_dependency "timecop", "~> 0.6.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thegarage-gitx
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0.beta1
 platform: ruby
 authors:
 - Ryan Sonnek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-11 00:00:00.000000000 Z
+date: 2013-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grit
@@ -122,10 +122,25 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.3
 description: Git eXtensions for common development workflow
 email:
 - ryan.sonnek@gmail.com
 executables:
+- git-buildtag
 - git-cleanup
 - git-integrate
 - git-nuke
@@ -140,12 +155,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - .ruby-gemset
 - .ruby-version
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/git-buildtag
 - bin/git-cleanup
 - bin/git-integrate
 - bin/git-nuke
@@ -163,6 +181,7 @@ files:
 - lib/thegarage/gitx/string_extensions.rb
 - lib/thegarage/gitx/version.rb
 - spec/spec_helper.rb
+- spec/support/meet_expectations_matcher.rb
 - spec/thegarage/gitx/cli_spec.rb
 - thegarage-gitx.gemspec
 homepage: ''
@@ -180,15 +199,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.5
+rubygems_version: 2.0.7
 signing_key: 
 specification_version: 4
 summary: Utility scripts for Git to increase productivity for common operations
 test_files:
 - spec/spec_helper.rb
+- spec/support/meet_expectations_matcher.rb
 - spec/thegarage/gitx/cli_spec.rb