flash_flow 1.0.0

data/test/lib/data/test_github.rb

@@ -0,0 +1,23 @@
+require 'minitest_helper'
+
+module FlashFlow
+  module Data
+    class TestGithub < Minitest::Test
+
+      class SomeFakeError < RuntimeError; end
+
+      def setup
+        # @github = Github.new('fake_repo')
+        # @octokit = Minitest::Mock.new
+      end
+
+      def test_cant_initialize_without_token
+        # val = ENV.delete('GH_TOKEN')
+        # assert_raises(RuntimeError) do
+        #   Github.new('fake_repo')
+        # end
+        # ENV['GH_TOKEN'] = val
+      end
+    end
+  end
+end

data/test/lib/data/test_store.rb

@@ -0,0 +1,53 @@
+require 'minitest_helper'
+require 'flash_flow/data/store'
+
+module FlashFlow
+  module Data
+    class TestStore < Minitest::Test
+      def sample_branches
+        {
+            'origin/branch 1' => {'branch' => 'branch 1', 'remote' => 'origin', 'status' => 'success', 'stories' => ['123']},
+            'other_origin/branch 2' => {'branch' => 'branch 2', 'remote' => 'origin', 'status' => 'success', 'stories' => ['456']}
+        }
+      end
+
+      def setup
+        @mock_git = MockGit.new
+        @collection = Collection.new({ 'origin' => 'the_origin_url' })
+        @branch = Branch.new('origin', 'the_origin_url', 'some_branch')
+        @storage = Store.new('/dev/null', @mock_git)
+      end
+
+      def test_get
+        @mock_git.stub(:read_file_from_merge_branch, JSON.pretty_generate(old_branches)) do
+          assert_equal(@storage.get, old_branches)
+        end
+      end
+
+      def test_write
+        str = StringIO.new
+        @storage.write(old_branches, str)
+
+        assert_equal(str.string.strip, JSON.pretty_generate(old_branches).strip)
+      end
+
+      private # Helpers
+
+      def old_branches
+        @old_branches ||= {
+            'the_origin_url/some_old_branch' => {'ref' => 'some_old_branch', 'remote_url' => 'the_origin_url', 'remote' => 'origin', 'created_at' => (Time.now - 3600).to_s, 'stories' => ['111']},
+            'the_origin_url/some_branch' => {'ref' => 'some_branch', 'remote_url' => 'the_origin_url', 'remote' => 'origin', 'status' => 'success', 'created_at' => (Time.now - 1800).to_s, 'stories' => ['222']}
+        }
+      end
+    end
+
+    class MockGit
+      def read_file_from_merge_branch; end
+      def add_and_commit(_,_,_=nil); end
+
+      def in_temp_merge_branch
+        yield
+      end
+    end
+  end
+end

data/test/lib/issue_tracker/test_pivotal.rb

@@ -0,0 +1,221 @@
+require 'minitest_helper'
+require 'flash_flow/issue_tracker/pivotal'
+require 'flash_flow/time_helper'
+
+module FlashFlow
+  module IssueTracker
+    class TestPivotal < Minitest::Test
+      include TimeHelper
+
+      def setup
+        @project_mock = MiniTest::Mock.new
+        @stories = MiniTest::Mock.new
+      end
+
+      def test_stories_pushed_only_marks_success_branches
+        stub_tracker_gem(@project_mock) do
+          [[0,'111'],[1,'222']].each do |branch, story|
+            mock_find(nil, story)
+            git = mock_working_branch(branch)
+
+            Pivotal.new(sample_branches, git).stories_pushed
+            @stories.verify
+          end
+        end
+      end
+
+      def test_stories_delivered_gets_success_and_removed_stories
+        stub_tracker_gem(@project_mock) do
+          mock_find(nil, '111')
+          mock_find(nil, '222')
+          mock_find(nil, '555')
+
+          Pivotal.new(sample_branches, nil).stories_delivered
+          @stories.verify
+        end
+      end
+
+      def test_stories_delivered_only_delivers_finished_stories
+        stub_tracker_gem(@project_mock) do
+          story1_mock = MiniTest::Mock.new
+                            .expect(:id, '111')
+                            .expect(:current_state, 'finished')
+                            .expect(:current_state=, true, ['delivered'])
+                            .expect(:update, true)
+          story2_mock = MiniTest::Mock.new
+                            .expect(:id, '222')
+                            .expect(:current_state, 'delivered')
+          story3_mock = MiniTest::Mock.new
+                            .expect(:id, '555')
+                            .expect(:current_state, 'removed')
+          mock_find(story1_mock)
+          mock_find(story2_mock)
+          mock_find(story3_mock)
+
+          Pivotal.new(sample_branches, nil).stories_delivered
+          story1_mock.verify
+          story2_mock.verify
+          story3_mock.verify
+        end
+      end
+
+      def test_stories_pushed_only_finishes_started_stories
+        stub_tracker_gem(@project_mock) do
+          story1_mock = MiniTest::Mock.new
+                            .expect(:id, '111')
+                            .expect(:current_state, 'started')
+                            .expect(:current_state=, true, ['finished'])
+                            .expect(:update, true)
+          story2_mock = MiniTest::Mock.new
+                            .expect(:id, '222')
+                            .expect(:current_state, 'finished')
+          mock_find(story1_mock)
+          mock_find(story2_mock)
+
+          [[0,story1_mock],[1,story2_mock]].each do |branch, story|
+            git = mock_working_branch(branch)
+
+            Pivotal.new(sample_branches, git).stories_pushed
+            story.verify
+          end
+        end
+      end
+
+      def test_stories_pushed_only_finishes_stories_of_current_branch
+        stub_tracker_gem(@project_mock) do
+          story1_mock = MiniTest::Mock.new
+                            .expect(:id, '111')
+                            .expect(:current_state, 'started')
+                            .expect(:current_state=, true, ['finished'])
+                            .expect(:update, true)
+          story2_mock = MiniTest::Mock.new
+                            .expect(:id, '222')
+          mock_find(story1_mock)
+          mock_find(story2_mock)
+
+          git = mock_working_branch(0)
+
+          Pivotal.new(sample_branches, git).stories_pushed
+          story1_mock.verify
+          story2_mock.verify
+        end
+      end
+
+      def test_production_deploy_only_comments_on_shipped_branches
+        stub_tracker_gem(@project_mock) do
+          mock_find(nil, '111')
+
+          Pivotal.new(sample_branches, mock_git).production_deploy
+          @stories.verify
+        end
+      end
+
+      def test_production_deploy_comments
+        shipped_text = with_time_zone("US/Pacific") { Time.now.strftime("Shipped to production on %m/%d/%Y at %H:%M") }
+        fake_notes = Minitest::Mock.new
+                          .expect(:all, [mock_comment('Some random comment'), mock_comment('Some other random comment')])
+                          .expect(:create, true, [{ text: shipped_text }])
+        story_mock = MiniTest::Mock.new
+                          .expect(:id, '111')
+                          .expect(:notes, fake_notes)
+                          .expect(:notes, fake_notes)
+
+        stub_tracker_gem(@project_mock) do
+          mock_find(story_mock)
+
+          Pivotal.new(sample_branches, mock_git, {'timezone' => "US/Pacific"}).production_deploy
+        end
+
+        story_mock.verify
+        fake_notes.verify
+      end
+
+      def test_production_deploy_only_comments_if_no_existing_comment
+        fake_notes = Minitest::Mock.new
+                          .expect(:all, [mock_comment('Some random comment'), mock_comment('Shipped to production on')])
+        story_mock = MiniTest::Mock.new
+                         .expect(:id, '111')
+                         .expect(:notes, fake_notes)
+
+        stub_tracker_gem(@project_mock) do
+          mock_find(story_mock)
+
+          Pivotal.new(sample_branches, mock_git).production_deploy
+        end
+
+        story_mock.verify
+        fake_notes.verify
+      end
+
+      def test_list_release_notes_with_time_scope
+        time = Time.now
+        time -= time.sec
+        time_now = time.strftime("%m/%d/%Y at %H:%M")
+        fake_notes = Minitest::Mock.new
+                      .expect(:all, [mock_comment('Some random comment'), mock_comment("Shipped to production on #{time_now}")])
+        story_mock = MiniTest::Mock.new
+                      .expect(:id, '111')
+                      .expect(:name, 'fake_name')
+                      .expect(:notes, fake_notes)
+        fake_file = MiniTest::Mock.new
+                      .expect(:puts, nil, ["PT#111 fake_name (#{time})"])
+
+        stub_tracker_gem(@project_mock) do
+          pivotal = Pivotal.new(sample_branches, mock_git)
+          pivotal.stub(:done_and_current_stories, [story_mock]) do
+            pivotal.release_notes(24, fake_file)
+          end
+        end
+
+        story_mock.verify
+        fake_notes.verify
+        fake_file.verify
+      end
+
+      private
+
+      def stub_tracker_gem(project)
+        PivotalTracker::Client.stub(:token=, true) do
+          PivotalTracker::Client.stub(:use_ssl=, true) do
+            PivotalTracker::Project.stub(:find, project) do
+              yield
+            end
+          end
+        end
+      end
+
+      def mock_git
+        Minitest::Mock.new
+            .expect(:master_branch_contains?, true, [sample_branches[0].sha])
+            .expect(:master_branch_contains?, false, [sample_branches[1].sha])
+            .expect(:master_branch_contains?, false, [sample_branches[2].sha])
+            .expect(:master_branch_contains?, false, [sample_branches[3].sha])
+            .expect(:master_branch_contains?, false, [sample_branches[4].sha])
+      end
+
+      def mock_working_branch(index)
+        git = Minitest::Mock.new
+        5.times { git.expect(:working_branch, sample_branches[index].ref) }
+        git
+      end
+
+      def mock_comment(comment)
+        Minitest::Mock.new.expect(:text, comment)
+      end
+
+      def mock_find(story, story_id=nil)
+        story_id ||= story.id
+        @project_mock.expect(:stories, @stories.expect(:find, story, [story_id]))
+      end
+
+      def sample_branches
+        @sample_branches ||= [Data::Branch.from_hash({'ref' => 'branch1', 'remote' => 'origin', 'sha' => 'sha1', 'status' => 'success', 'created_at' => (Time.now - 3600), 'stories' => ['111']}),
+            Data::Branch.from_hash({'ref' => 'branch2', 'remote' => 'origin', 'sha' => 'sha2', 'status' => 'success', 'created_at' => (Time.now - 1800), 'stories' => ['222']}),
+            Data::Branch.from_hash({'ref' => 'branch3', 'remote' => 'origin', 'sha' => 'sha3', 'status' => 'fail', 'created_at' => (Time.now - 1800), 'stories' => ['333']}),
+            Data::Branch.from_hash({'ref' => 'branch4', 'remote' => 'origin', 'sha' => 'sha4', 'status' => nil, 'created_at' => (Time.now - 1800), 'stories' => ['444']}),
+            Data::Branch.from_hash({'ref' => 'branch5', 'remote' => 'origin', 'sha' => 'sha5', 'status' => 'removed', 'created_at' => (Time.now - 1800), 'stories' => ['555']})
+        ]
+      end
+    end
+  end
+end

data/test/lib/lock/test_github.rb

@@ -0,0 +1,70 @@
+require 'minitest_helper'
+require 'minitest/stub_any_instance'
+
+module FlashFlow
+  module Lock
+    class TestGithub < Minitest::Test
+      class SomeFakeError < RuntimeError;
+      end
+
+      def setup
+        @lock = Lock::Github.new(params)
+      end
+
+      def test_raises_without_required_params
+        config = params.select { |k, _| k != 'token' }
+        assert_raises(Lock::Error) { Lock::Github.new(config) }
+
+        config = params.select { |k, _| k != 'repo' }
+        assert_raises(Lock::Error) { Lock::Github.new(config) }
+
+        config = params.select { |k, _| k != 'issue_id' }
+        assert_raises(Lock::Error) { Lock::Github.new(config) }
+      end
+
+      def test_error_message_when_issue_opened
+        @lock.stub(:issue_open?, true) do
+          @lock.stub(:get_last_event, {actor: {login: 'anonymous'}, created_at: Time.now}) do
+            assert_raises(FlashFlow::Lock::Error) do
+              @lock.with_lock
+            end
+          end
+        end
+      end
+
+      def test_with_lock_calls_the_block
+        my_mock = Minitest::Mock.new.expect(:block_call, true).expect(:close_issue, true)
+
+        @lock.stub(:issue_open?, false) do
+          @lock.stub(:open_issue, nil) do
+            @lock.stub(:close_issue, -> { my_mock.close_issue }) do
+              @lock.with_lock { my_mock.block_call }
+              my_mock.verify
+            end
+          end
+        end
+      end
+
+      def test_with_lock_closes_issue_no_matter_what
+        my_mock = Minitest::Mock.new.expect(:some_method, true)
+
+        @lock.stub(:issue_open?, false) do
+          @lock.stub(:open_issue, nil) do
+            @lock.stub(:close_issue, -> { my_mock.some_method }) do
+              assert_raises(SomeFakeError) do
+                @lock.with_lock { raise SomeFakeError }
+                my_mock.verify
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def params
+        {'token' => '1234567890', 'repo' => 'f/f', 'issue_id' => '123'}
+      end
+    end
+  end
+end

data/test/lib/test_branch_merger.rb

@@ -0,0 +1,76 @@
+require 'minitest_helper'
+require 'minitest/stub_any_instance'
+
+module FlashFlow
+  class TestBranchMerger < Minitest::Test
+
+    def setup
+    end
+
+    def test_deleted_branch
+      merger.stub(:sha, nil) do
+        assert_equal(merger.do_merge(true), :deleted)
+      end
+    end
+
+    def test_successful_merge
+      git.expect(:last_success?, true)
+
+      merger.stub(:sha, 'some_sha') do
+        assert_equal(merger.do_merge(false), :success)
+      end
+    end
+
+    def test_successful_rerere
+      git.expect(:last_success?, false)
+          .expect(:rerere_resolve!, true)
+
+      merger.stub(:sha, 'some_sha') do
+        assert_equal(merger.do_merge(false), :success)
+      end
+    end
+
+    def test_rerere_forget
+      git.expect(:last_success?, false)
+          .expect(:run, true, [ 'rerere forget' ])
+          .expect(:run, true, [ 'reset --hard HEAD' ])
+          .expect(:run, true, [ 'rev-parse HEAD' ])
+          .expect(:last_stdout, 'conflict sha', )
+
+      merger.stub(:sha, 'some_sha') do
+        assert_equal(merger.do_merge(true), :conflict)
+      end
+    end
+
+    def test_failed_rerere
+      git.expect(:last_success?, false)
+          .expect(:rerere_resolve!, false)
+          .expect(:run, true, [ 'reset --hard HEAD' ])
+          .expect(:run, true, [ 'rev-parse HEAD' ])
+          .expect(:last_stdout, 'conflict sha', )
+
+      merger.stub(:sha, 'some_sha') do
+        assert_equal(merger.do_merge(false), :conflict)
+        assert_equal(merger.conflict_sha, 'conflict sha')
+      end
+    end
+
+    private
+
+    def merger
+      @merger ||= BranchMerger.new(git, branch)
+    end
+
+    def branch
+      @branch ||= Data::Branch.from_hash({'ref' => 'pushing_branch', 'remote' => 'origin', 'status' => 'fail', 'stories' => []})
+    end
+
+    def git
+      return @git if @git
+
+      @git = Minitest::Mock.new
+      @git.expect(:run, true, ["merge --no-ff #{branch.remote}/#{branch.ref}"])
+    end
+
+  end
+end