daq_flow 1.0.4

data/test/lib/data/test_store.rb

@@ -0,0 +1,70 @@
+require 'minitest_helper'
+require 'flash_flow/data/store'
+
+module FlashFlow
+  module Data
+    class TestStore < Minitest::Test
+      def setup
+        @mock_git = MockGit.new
+        @collection = Collection.new
+        @branch = Branch.new('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(sorted_branches).strip)
+      end
+
+      private # Helpers
+
+      def old_branches
+        @old_branches ||= {
+            'version' => '1.0.0',
+            'branches' => {
+              'some_old_branch' => {'ref' => 'some_old_branch', 'created_at' => (Time.now - 3600).to_s, 'stories' => ['111']},
+              'some_branch' => {'ref' => 'some_branch', 'status' => 'success', 'created_at' => (Time.now - 1800).to_s, 'stories' => ['222']}
+            }
+          }
+      end
+
+      def sorted_branches
+        @sorted_branches ||= {
+            'branches' => {
+                'some_branch' => {
+                    'created_at' => (Time.now - 1800).to_s,
+                    'ref' => 'some_branch',
+                    'status' => 'success',
+                    'stories' => ['222']
+                },
+                'some_old_branch' => {
+                    'created_at' => (Time.now - 3600).to_s,
+                    'ref' => 'some_old_branch',
+                    'stories' => ['111']},
+            },
+            'version' => '1.0.0',
+        }
+      end
+    end
+
+    class MockGit
+      def read_file_from_merge_branch; end
+      def add_and_commit(_,_,_=nil); end
+
+      def in_dir
+        yield
+      end
+      def in_temp_merge_branch
+        yield
+      end
+    end
+  end
+end

data/test/lib/lock/test_github.rb

@@ -0,0 +1,74 @@
+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_locked
+        @lock.stub(:actor, 'actor') do
+          @lock.stub(:issue_locked?, true) do
+            @lock.stub(:get_lock_labels, {name: @lock.send(:locked_label)}) do
+              assert_raises(FlashFlow::Lock::Error) do
+                @lock.with_lock
+              end
+            end
+          end
+        end
+      end
+
+      def test_with_lock_calls_the_block
+        my_mock = Minitest::Mock.new.expect(:block_call, true).expect(:unlock_issue, true)
+
+        @lock.stub(:issue_locked?, false) do
+          @lock.stub(:lock_issue, nil) do
+            @lock.stub(:unlock_issue, -> { my_mock.unlock_issue }) do
+              @lock.with_lock { my_mock.block_call }
+              my_mock.verify
+            end
+          end
+        end
+      end
+
+      def test_with_unlock_issue_no_matter_what
+        my_mock = Minitest::Mock.new
+          .expect(:some_method, true)
+          .expect(:actor, 'actor')
+
+        @lock.stub(:issue_locked?, false) do
+          @lock.stub(:lock_issue, nil) do
+            @lock.stub(:unlock_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/merge/test_acceptance.rb

@@ -0,0 +1,230 @@
+require 'minitest_helper'
+require 'minitest/stub_any_instance'
+
+module FlashFlow
+  module Merge
+    class TestAcceptance < Minitest::Test
+
+      def setup
+        reset_config!
+        config!(git:
+                    {
+                        'merge_branch' => 'test_acceptance',
+                        'remote' => 'test_remote',
+                        'master_branch' => 'test_master',
+                        'use_rerere' => true
+                    },
+                branches: {}
+        )
+
+        @branch = Data::Branch.from_hash({'ref' => 'pushing_branch', 'status' => 'fail', 'stories' => []})
+        @deploy = Acceptance.new
+      end
+
+      def test_version_is_nil
+        with_versions('1.1.1', nil) do
+          assert_nil(@deploy.check_version)
+        end
+      end
+
+      def test_check_version_greater
+        with_versions('2.0.0', '1.1.1') do
+          assert_nil(@deploy.check_version)
+        end
+
+        with_versions('1.2.0', '1.1.1') do
+          assert_nil(@deploy.check_version)
+        end
+      end
+
+      def test_check_version_less_raises
+        with_versions('1.1.1', '2.1.0') do
+          assert_raises(RuntimeError) { @deploy.check_version }
+        end
+
+        with_versions('1.2.0', '2.1.0') do
+          assert_raises(RuntimeError) { @deploy.check_version }
+        end
+      end
+
+      def test_git_version_is_nil
+        with_git_versions(nil, '2.0.0') do
+          assert_nil(@deploy.check_git_version)
+        end
+      end
+
+      def test_check_git_version_greater
+        with_git_versions('3.0.0', '2.0.0') do
+          assert_nil(@deploy.check_git_version)
+        end
+
+        with_git_versions('2.15.1', '2.0.0') do
+          assert_nil(@deploy.check_git_version)
+        end
+      end
+
+      def test_check_git_version_less_raises
+        with_git_versions('2.0.0', '2.15.1') do
+          assert_output(/Warning/) { @deploy.check_git_version }
+        end
+
+        with_git_versions('1.7.8', '2.15.1') do
+          assert_output(/Warning/) { @deploy.check_git_version }
+        end
+      end
+
+      def test_print_errors_with_no_errors
+        data.expect(:failures, [])
+        assert_equal(@deploy.format_errors, 'Success!')
+      end
+
+      def test_print_errors_when_current_branch_cant_merge
+        data.expect(:failures, [@branch])
+        @branch.fail!('some_random_sha')
+
+        current_branch_error = "ERROR: Your branch did not merge to test_acceptance. Run 'flash_flow --resolve', fix the merge conflict(s) and then re-run this script\n"
+
+        @deploy.instance_variable_get('@local_git'.to_sym).stub(:working_branch, 'pushing_branch') do
+          assert_equal(current_branch_error, @deploy.format_errors)
+        end
+      end
+
+      def test_print_errors_when_another_branch_cant_merge
+        data.expect(:failures, [@branch])
+
+        other_branch_error = "WARNING: Unable to merge branch test_remote/pushing_branch to test_acceptance due to conflicts."
+
+        assert_equal(@deploy.format_errors, other_branch_error)
+      end
+
+      def test_check_out_to_working_branch
+        @deploy.stub(:check_repo, true) do
+          @deploy.stub(:check_version, true) do
+            Lock::Base.stub_any_instance(:with_lock, -> { raise Lock::Error }) do
+              assert_output(/Failure!/) { @deploy.run }
+            end
+          end
+        end
+      end
+
+      def test_deleted_branch
+        data.expect(:mark_deleted, true, [@branch])
+
+        notifier.expect(:deleted_branch, true, [@branch])
+
+        merger.expect(:result, :deleted)
+
+        @deploy.process_result(@branch, merger)
+
+        notifier.verify
+        data.verify
+        merger.verify
+      end
+
+      def test_merge_conflict
+        data.expect(:mark_failure, true, [@branch, nil])
+
+        notifier.expect(:merge_conflict, true, [@branch])
+
+        merger.expect(:result, :conflict)
+
+        @deploy.process_result(@branch, merger)
+
+        notifier.verify
+        data.verify
+        merger.verify
+      end
+
+      def test_successful_merge
+        data.expect(:mark_success, true, [@branch])
+        data.expect(:set_resolutions, true, [@branch, {'filename' => ["resolution_sha"]}])
+
+        merger.
+            expect(:result, :success).
+            expect(:sha, 'sha').
+            expect(:resolutions, {'filename' => ["resolution_sha"]})
+
+        @deploy.process_result(@branch, merger)
+
+        data.verify
+        merger.verify
+        assert_equal(@branch.sha, 'sha')
+      end
+
+      def test_ignore_pushing_master_or_acceptance
+        ['test_master', 'test_acceptance'].each do |branch|
+          @deploy.instance_variable_get('@local_git'.to_sym).stub(:working_branch, branch) do
+            refute(@deploy.open_pull_request)
+          end
+        end
+      end
+
+      def test_commit_message_ordering
+        data
+            .expect(:successes, ['data_successes'])
+            .expect(:successes, sample_branches)
+            .expect(:failures, [])
+            .expect(:removals, [])
+
+        expected_message = sample_branches.sort_by(&:merge_order).map(&:ref).join("\n")
+        assert_output(/#{expected_message}/) { print @deploy.commit_message }
+        data.verify
+      end
+
+      private
+
+      def with_versions(current, written)
+        original_version = FlashFlow::VERSION
+        FlashFlow.send(:remove_const, :VERSION)
+        FlashFlow.const_set(:VERSION, current)
+        data.expect(:version, written)
+        yield
+        data.verify
+        FlashFlow.send(:remove_const, :VERSION)
+        FlashFlow.const_set(:VERSION, original_version)
+      end
+
+      def with_git_versions(running, expected)
+        original_version = FlashFlow::GIT_VERSION
+        FlashFlow.send(:remove_const, :GIT_VERSION)
+        FlashFlow.const_set(:GIT_VERSION, expected)
+        local_git.expect(:version, running)
+        yield
+        local_git.verify
+        FlashFlow.send(:remove_const, :GIT_VERSION)
+        FlashFlow.const_set(:GIT_VERSION, original_version)
+      end
+
+      def merger
+        @merger ||= Minitest::Mock.new
+      end
+
+      def notifier
+        return @notifier if @notifier
+
+        @notifier = Minitest::Mock.new
+        @deploy.instance_variable_set('@notifier'.to_sym, @notifier)
+      end
+
+      def data
+        return @data if @data
+
+        @data = Minitest::Mock.new
+        @deploy.instance_variable_set('@data'.to_sym, @data)
+      end
+
+      def local_git
+        return @local_git if @local_git
+
+        @local_git = Minitest::Mock.new
+        @deploy.instance_variable_set('@local_git'.to_sym, @local_git)
+      end
+
+      def sample_branches
+        @sample_branches ||= [Data::Branch.from_hash({'ref' => 'branch3', 'merge_order' => 2}),
+                              Data::Branch.from_hash({'ref' => 'branch1', 'merge_order' => 3}),
+                              Data::Branch.from_hash({'ref' => 'branch2', 'merge_order' => 1})]
+      end
+    end
+  end
+end

data/test/lib/test_branch_merger.rb

@@ -0,0 +1,78 @@
+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
+        merger.do_merge(true)
+        assert_equal(merger.result, :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', 'status' => 'fail', 'stories' => []})
+    end
+
+    def git
+      return @git if @git
+
+      @git = Minitest::Mock.new
+      @git.expect(:remote, 'origin', [])
+      @git.expect(:run, true, ["merge --no-ff origin/#{branch.ref}"])
+    end
+
+  end
+end