git_workflow 0.0.5

data/spec/core_functionality/4199841_need_callbacks_for_my_workflow_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe GitWorkflow::Git do
+  before(:each) do
+    @git, @repository = Class.new, mock('Repository')
+    @git.send(:extend, GitWorkflow::Git)
+    @git.stub(:repository).and_return(@repository)
+
+    @git.stub(:info).with(anything)
+  end
+
+  describe '#in_git_branch' do
+    before(:each) do
+      @repository.should_receive(:current_branch).ordered.and_return('current')
+    end
+
+    it 'does not switch back if an error occurs' do
+      @repository.should_receive(:checkout).with('new_branch').ordered
+
+      lambda do
+        @git.in_git_branch('new_branch') { raise StandardError, 'Failed' }
+      end.should raise_error(StandardError)
+    end
+
+    context 'with a successful block' do
+      before(:each) do
+        @callback = mock('callback')
+        @callback.should_receive(:called)
+      end
+
+      after(:each) do
+        @git.in_git_branch(@target_branch) { @callback.called }
+      end
+
+      it 'simply yields if the current branch is the requested branch' do
+        @target_branch = 'current'
+      end
+
+      it 'switches to the new branch and back again for success' do
+        @target_branch = 'new_branch'
+
+        @repository.should_receive(:checkout).with('new_branch').ordered
+        @repository.should_receive(:checkout).with('current').ordered
+      end
+    end
+  end
+end
+
+class GitWorkflow::Git::Repository
+  def self.for_testing
+    new
+  end
+
+  def internal_current_branch
+    @current_branch
+  end
+end
+
+describe GitWorkflow::Git::Repository do
+  before(:each) do
+    @repository = described_class.for_testing
+  end
+
+  describe '#current_branch' do
+    it 'finds the current branch from the list' do
+      @repository.should_receive(:execute_command).with('git branch').and_return([ '   branch_1', '* branch_2', '   branch_3' ].join("\n"))
+      @repository.current_branch.should == 'branch_2'
+    end
+
+    it 'raises if the current branch cannot be found in the list' do
+      @repository.should_receive(:execute_command).with('git branch').and_return([ '   branch_1', '  branch_2', '   branch_3' ].join("\n"))
+      lambda { @repository.current_branch }.should raise_error(GitWorkflow::Git::Repository::BranchError)
+    end
+  end
+
+  describe '#checkout' do
+    it 'raises CheckoutError on command failure' do
+      @repository.should_receive(:execute_command).with(anything).and_raise(Execution::CommandFailure.new('command', :fail))
+      lambda { @repository.checkout('target') }.should raise_error(GitWorkflow::Git::Repository::CheckoutError)
+    end
+
+    context 'on successful checkout' do
+      before(:each) do
+        @repository.should_receive(:execute_command).with('git checkout target')
+        @repository.checkout('target')
+      end
+
+      it 'checks out the requested branch' do
+        # Nothing needed here
+      end
+
+      it 'maintains the current branch for performance' do
+        @repository.internal_current_branch.should == 'target'
+      end
+    end
+  end
+end

data/spec/extensions/4199841_need_callbacks_for_my_workflow_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+require 'git_workflow/callbacks/styles/mine'
+
+describe String do
+  describe '#camelize' do
+    it 'camelizes an underscored word' do
+      'foo_bar_baz'.camelize.should == 'FooBarBaz'
+    end
+
+    it 'modularizes a path' do
+      'foo/bar/baz'.camelize.should == 'Foo::Bar::Baz'
+    end
+  end
+
+  describe '#underscore' do
+    it 'underscores a modular string' do
+      'Foo::Bar::Baz'.underscore.should == 'foo/bar/baz'
+    end
+
+    it 'underscores a camelized word' do
+      'FooBarBaz'.underscore.should == 'foo_bar_baz'
+    end
+  end
+end
+
+describe GitWorkflow::Callbacks::Styles::Mine::FinishBehaviour do
+  before(:each) do
+    @callbacks = Class.new
+    @callbacks.send(:extend, GitWorkflow::Callbacks::Styles::Mine::FinishBehaviour)
+  end
+
+  describe '#finish' do
+    before(:each) do
+      @story = mock('Story')
+      @story.stub(:branch_name).and_return('story_branch')
+
+      @callbacks.should_receive(:in_git_branch).with('story_branch').and_yield.ordered
+      @callbacks.should_receive(:run_tests!).with(:spec, :features).ordered
+    end
+
+    after(:each) do
+      @callbacks.finish(@story, @target_branch)
+    end
+
+    it 'runs the tests but not the push if non-master branch' do
+      @target_branch = 'non-master'
+
+      @callbacks.should_receive(:in_git_branch).with(@target_branch).and_yield.ordered
+      @callbacks.should_receive(:merge_branch).with('story_branch', anything).ordered
+      @callbacks.should_receive(:run_tests_with_recovery!).with(:spec, :features).ordered
+
+      @callbacks.should_not_receive(:push_current_branch_to).with('non-master').ordered
+    end
+
+    it 'runs the tests and the push if master branch' do
+      @target_branch = 'master'
+
+      @callbacks.should_receive(:in_git_branch).with(@target_branch).and_yield.ordered
+      @callbacks.should_receive(:merge_branch).with('story_branch', anything).ordered
+      @callbacks.should_receive(:run_tests_with_recovery!).with(:spec, :features).ordered
+
+      @callbacks.should_receive(:push_current_branch_to).with('master').ordered
+    end
+  end
+end
+
+describe GitWorkflow::Callbacks::Styles::Mine do
+  describe '.setup' do
+    before(:each) do
+      @start, @finish = Class.new, Class.new
+
+      GitWorkflow::Callbacks::Styles::Mine.setup(@start, @finish)
+    end
+
+    context 'configured start' do
+      it 'has my callbacks installed' do
+        @start.included_modules.should include(GitWorkflow::Callbacks::Styles::Mine::StartBehaviour)
+      end
+    end
+
+    context 'configured finish' do
+      it 'has the Pivotal Tracker support' do
+        @finish.included_modules.should include(GitWorkflow::Callbacks::PivotalTrackerSupport)
+      end
+
+      it 'has the test code support' do
+        @finish.included_modules.should include(GitWorkflow::Callbacks::TestCodeSupport)
+      end
+
+      it 'has the remote git branch support' do
+        @finish.included_modules.should include(GitWorkflow::Callbacks::RemoteGitBranchSupport)
+      end
+
+      it 'has my callbacks installed' do
+        @finish.included_modules.should include(GitWorkflow::Callbacks::Styles::Mine::FinishBehaviour)
+      end
+    end
+  end
+end
+
+describe GitWorkflow::Callbacks::TestCodeSupport do
+  before(:each) do
+    @callbacks = Class.new
+    @callbacks.send(:extend, GitWorkflow::Callbacks::TestCodeSupport)
+  end
+
+  describe '#run_tests!' do
+    it 'does nothing if the tests pass' do
+      @callbacks.should_receive(:run_tests).with(:task1, :task2).once.and_return(true)
+
+      @callbacks.run_tests!(:task1, :task2)
+    end
+
+    it 'raises if the tests fail' do
+      @callbacks.should_receive(:run_tests).with(:task1, :task2).once.and_return(false)
+
+      lambda { @callbacks.run_tests!(:task1, :task2) }.should raise_error(GitWorkflow::Callbacks::TestCodeSupport::Failure)
+    end
+  end
+
+  describe '#run_tests_with_recovery!' do
+    it 'does nothing if the tests pass' do
+      @callbacks.should_receive(:run_tests).with(:task1, :task2).once.and_return(true)
+
+      @callbacks.run_tests_with_recovery!(:task1, :task2)
+    end
+
+    it 'tries to recover from failing tests' do
+      @callbacks.should_receive(:run_tests).with(:task1, :task2).twice.and_return(false, true)
+      @callbacks.should_receive(:spawn_shell_for_recovery).once.and_return(true)
+
+      @callbacks.run_tests_with_recovery!(:task1, :task2)
+    end
+
+    it 'raises if the recovery is not possible' do
+      @callbacks.should_receive(:run_tests).with(:task1, :task2).once.and_return(false)
+      @callbacks.should_receive(:spawn_shell_for_recovery).once.and_return(false)
+
+      lambda { @callbacks.run_tests_with_recovery!(:task1, :task2) }.should raise_error(GitWorkflow::Callbacks::TestCodeSupport::Failure)
+    end
+  end
+
+  describe '#run_tests' do
+    it 'executes the given rake tasks' do
+      @callbacks.should_receive(:system).with('rake', 'task1', 'task2').and_return(true)
+      @callbacks.send(:run_tests, :task1, :task2).should == true
+    end
+
+    it 'returns the result of execution' do
+      @callbacks.should_receive(:system).with('rake', 'task1', 'task2').and_return(false)
+      @callbacks.send(:run_tests, :task1, :task2).should == false
+    end
+  end
+
+  describe '#spawn_shell_for_recovery' do
+  end
+end
+
+describe GitWorkflow::Callbacks::RemoteGitBranchSupport do
+  before(:each) do
+    @callbacks = Class.new
+    @callbacks.send(:extend, GitWorkflow::Callbacks::RemoteGitBranchSupport)
+  end
+
+  describe '#push_current_branch_to' do
+  end
+end

data/spec/extensions/4205913_output_from_rake_tests_should_be_seen_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Execution do
+  before(:each) do
+    @executor = Class.new
+    @executor.send(:extend, Execution)
+    @executor.stub(:debug).with(anything).and_yield
+  end
+
+  before(:each) do
+    @stdin, @stdout, @stderr = mock('stdin'), mock('stdout'), mock('stderr')
+    @outputs = [ @stdout, @stderr, @stdin ]
+  end
+
+  describe '#execute_command' do
+    it 'returns the output from the command' do
+      @stdout.should_receive(:read).and_return('Hello World')
+      @executor.should_receive(:execute_command_with_output_handling).with(:command).and_yield(*@outputs)
+      @executor.execute_command(:command).should == 'Hello World'
+    end
+  end
+
+  describe '#execute_command_with_output_handling' do
+    it 'does not raise if the command succeeds' do
+      @executor.execute_command_with_output_handling('sh -c "exit 0"') { |*args| }
+    end
+
+    it 'raises if the command fails' do
+      lambda do
+        @executor.execute_command_with_output_handling('sh -c "exit 1"') { |*args| }
+      end.should raise_error(Execution::CommandFailure)
+    end
+  end
+end

data/spec/git_branching/4058723_branches_end_in_if_the_last_character_is_invalid_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+class GitWorkflow::Story
+  attr_writer :name
+end
+
+describe GitWorkflow::Story do
+  describe '#branch_name' do
+    it_should_behave_like 'it needs a working Story'
+
+    it 'delegates to the local branch convention' do
+      configuration, convention = mock('configuration'), mock('convention')
+      configuration.should_receive(:local_branch_convention).and_return(convention)
+      convention.should_receive(:to).with(@story).and_return(:ok)
+      GitWorkflow::Configuration.stub!(:instance).and_return(configuration)
+
+      @story.branch_name.should == :ok
+    end
+  end
+end
+
+describe GitWorkflow::Configuration::Convention do 
+  describe '#to' do
+    before(:each) do
+      @convention = described_class.new('${number}_${name}')
+    end
+
+    after(:each) do
+      @convention.to(OpenStruct.new(:story_id => 12345, :name => @name)).should_not match(/_+$/)
+    end
+
+    it 'does not end in underscore with invalid character at the end' do
+      @name = 'ends in invalid character!'
+    end
+
+    it 'does not end in multiple underscores' do
+      @name = 'ends in invalid characters!!!!!!!'
+    end
+  end
+end

data/spec/git_branching/4059824_code_is_not_using_workflow_localbranchconvention_to_decode_branch_names_on_finish_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+class GitWorkflow::Configuration
+  def self.instance_for_testing
+    new
+  end
+end
+
+describe GitWorkflow::Configuration do
+  describe '#local_branch_convention' do
+    before(:each) do
+      @configuration = GitWorkflow::Configuration.instance_for_testing
+      @configuration.should_receive(:get_config_value_for!).with('workflow.localbranchconvention').once.and_return('${number}_${name}')
+    end
+
+    it 'uses the workflow.localbranchconvention configuration value' do
+      @configuration.local_branch_convention
+    end
+
+    it 'caches the value' do
+      @configuration.local_branch_convention # Gets the value ...
+      @configuration.local_branch_convention # ... that should now be cached
+    end
+  end
+end
+
+class GitWorkflow::Commands::Finish
+  public :extract_story_from_branch
+end
+
+describe GitWorkflow::Commands::Finish do
+  before(:each) do
+    @configuration = mock('configuration')
+    @configuration.stub(:ignore_git_global?).and_return(false)
+    GitWorkflow::Configuration.stub!(:instance).and_return(@configuration)
+
+    @command = described_class.new([])
+  end
+
+  describe '#extract_story_from_branch' do
+    before(:each) do
+      @convention = mock('convention')
+      @configuration.stub!(:local_branch_convention).and_return(@convention)
+    end
+
+    it 'uses the branch convention' do
+      @convention.should_receive(:from).with('12345_this_branch_matches').and_return(12345)
+      @command.extract_story_from_branch('12345_this_branch_matches').should == 12345
+    end
+  end
+end
+
+describe GitWorkflow::Configuration::Convention do
+  describe '#initialize' do
+    it 'errors if the convention has no story_id' do
+      lambda { described_class.new('foo') }.should raise_error(StandardError)
+    end
+
+    it 'does not error if story_id included' do
+      described_class.new('${number}_foo')
+    end
+  end
+
+  shared_examples_for 'branch convention behaviour' do
+    before(:each) do
+      @branches   = { :start => '12345_works_for_me', :end => 'works_for_me_12345' }
+    end
+
+    describe '#to' do
+      before(:each) do
+        @decoder = described_class.new(@convention)
+        @decoder.stub!(:use_existing_for).with(anything).and_return(nil)
+      end
+
+      it 'evaluates the convention string' do
+        story = OpenStruct.new(:story_id => 12345, :name => 'works for me')
+        @decoder.to(story).should == @branches[ @to_result ]
+      end
+    end
+
+    describe '#from' do
+      before(:each) do
+        @decoder = described_class.new(@convention)
+      end
+
+      it 'decodes the same branch that #to produces' do
+        @decoder.from(@branches[ @to_result ]).should == 12345
+      end
+
+      it 'errors if the branch does not conform to the convention' do
+        lambda { @decoder.from(@branches[ @from_mismatch ]) }.should raise_error(StandardError)
+      end
+    end
+  end
+
+  context 'after successful initialization' do
+    context 'with ${number}_${name}' do
+      it_should_behave_like 'branch convention behaviour'
+
+      before(:each) do
+        @convention                = '${number}_${name}'
+        @to_result, @from_mismatch = :start, :end
+      end
+    end
+
+    context 'with ${name}_${number}' do
+      it_should_behave_like 'branch convention behaviour'
+
+      before(:each) do
+        @convention                = '${name}_${number}'
+        @to_result, @from_mismatch = :end, :start
+      end
+    end
+  end
+end