flash_flow 1.0.0

data/lib/flash_flow/time_helper.rb

@@ -0,0 +1,11 @@
+module FlashFlow
+  module TimeHelper
+    def with_time_zone(tz_name)
+      prev_tz = ENV['TZ']
+      ENV['TZ'] = tz_name
+      yield
+    ensure
+      ENV['TZ'] = prev_tz
+    end
+  end
+end

data/lib/flash_flow/version.rb

@@ -0,0 +1,3 @@
+module FlashFlow
+  VERSION = "1.0.0"
+end

data/test/lib/data/test_base.rb

@@ -0,0 +1,10 @@
+require 'minitest_helper'
+require 'flash_flow/data/store'
+
+module FlashFlow
+  module Data
+    class TestBase < Minitest::Test
+      # Embarrassingly lazy. Write some tests.
+    end
+  end
+end

data/test/lib/data/test_branch.rb

@@ -0,0 +1,203 @@
+require 'minitest_helper'
+require 'flash_flow/data/store'
+
+module FlashFlow
+  module Data
+    class TestBranch < Minitest::Test
+
+      def test_merge_returns_self_if_other_is_nil
+        branch = Branch.from_hash(branch_hash)
+        assert_equal(branch.merge(nil), branch)
+      end
+
+      def test_merge_keeps_the_oldest_created_at
+        new_branch = Branch.from_hash(branch_hash)
+        old_branch = Branch.from_hash(branch_hash)
+        old_branch.created_at -= 1000
+
+        assert_equal(new_branch.merge(old_branch).created_at, old_branch.created_at)
+        assert_equal(old_branch.merge(new_branch).created_at, old_branch.created_at)
+      end
+
+      def test_merge_handles_nil_stories
+        new_branch = Branch.from_hash(branch_hash)
+        old_branch = Branch.from_hash(branch_hash)
+
+        new_branch.stories = nil
+        old_branch.stories = ['456', '789']
+
+        assert_equal(old_branch.merge(new_branch).stories, ['456', '789'])
+        assert_equal(new_branch.merge(old_branch).stories, ['456', '789'])
+      end
+
+      def test_merge_unions_the_stories
+        new_branch = Branch.from_hash(branch_hash)
+        old_branch = Branch.from_hash(branch_hash)
+
+        new_branch.stories = ['123', '456']
+        old_branch.stories = ['456', '789']
+
+        assert_equal(new_branch.merge(old_branch).stories, ['123', '456', '789'])
+      end
+
+      def test_merge_uses_other_status
+        new_branch = Branch.from_hash(branch_hash)
+        old_branch = Branch.from_hash(branch_hash)
+
+        old_branch.success!
+        new_branch.fail!
+        old_branch.merge(new_branch)
+
+        assert(old_branch.fail?)
+        assert(new_branch.fail?)
+      end
+
+      def test_merge_sets_updated_at
+        new_branch = Branch.from_hash(branch_hash)
+        old_branch = Branch.from_hash(branch_hash)
+
+        original_updated_at = new_branch.updated_at
+
+        assert(old_branch.merge(new_branch).updated_at > original_updated_at)
+      end
+
+      def test_merge_sets_created_at_if_not_set
+        new_branch = Branch.from_hash(branch_hash)
+        old_branch = Branch.from_hash(branch_hash)
+
+        new_branch.created_at = old_branch.created_at = nil
+
+        assert_in_delta(old_branch.merge(new_branch).created_at.to_i, Time.now.to_i, 100)
+      end
+
+      def test_from_hash
+        branch = Branch.from_hash(branch_hash)
+        assert_equal(branch.ref, branch_hash['ref'])
+        assert_equal(branch.remote_url, branch_hash['remote_url'])
+        assert_equal(branch.remote, branch_hash['remote'])
+        assert_equal(branch.status, branch_hash['status'])
+        assert_equal(branch.stories, branch_hash['stories'])
+        assert_equal(branch.metadata, branch_hash['metadata'])
+      end
+
+      def test_from_hash_with_time_objects
+        branch_hash['updated_at'] = Time.now - 200
+        branch_hash['created_at'] = Time.now - 200
+        branch = Branch.from_hash(branch_hash)
+        assert_equal(branch.updated_at, branch_hash['updated_at'])
+        assert_equal(branch.created_at, branch_hash['created_at'])
+      end
+
+      def test_from_hash_with_nil_times
+        time = Time.parse('2015-05-22 09:47:07 -0700')
+        branch_hash['updated_at'] = branch_hash['created_at'] = nil
+        Time.stub(:now, time) do
+          branch = Branch.from_hash(branch_hash)
+
+          assert_equal(branch.updated_at, time)
+          assert_equal(branch.created_at, time)
+        end
+      end
+
+      def test_from_hash_with_string_times
+        time = Time.parse('2015-05-22 09:47:07 -0700')
+        branch_hash['updated_at'] = '2015-05-22 09:47:07 -0700'
+        branch_hash['created_at'] = '2015-05-22 09:47:07 -0700'
+        branch = Branch.from_hash(branch_hash)
+        assert_equal(branch.updated_at, time)
+        assert_equal(branch.created_at, time)
+      end
+
+      def test_double_equals
+        branch1 = Branch.from_hash(branch_hash)
+        branch2 = Branch.from_hash(branch_hash)
+        assert(branch1 == branch2)
+
+        branch1.remote_url = 'different_url'
+        refute(branch1 == branch2)
+
+        branch1.remote_url = branch2.remote_url
+        branch1.remote = 'different remote'
+        refute(branch1 == branch2)
+
+        branch1.remote = branch2.remote
+        branch1.ref = 'different ref'
+        refute(branch1 == branch2)
+      end
+
+      def test_to_hash
+        branch1 = Branch.from_hash(branch_hash)
+        assert_equal(branch1.to_hash, branch_hash)
+      end
+
+      def test_success
+        branch = Branch.new(1,2,3)
+
+        branch.success!
+        assert(branch.success?)
+
+        branch.fail!
+        refute(branch.success?)
+      end
+
+      def test_fail
+        branch = Branch.new(1,2,3)
+
+        branch.fail!
+        assert(branch.fail?)
+
+        branch.success!
+        refute(branch.fail?)
+      end
+
+      def test_removed
+        branch = Branch.new(1,2,3)
+
+        branch.removed!
+        assert(branch.removed?)
+
+        branch.success!
+        refute(branch.removed?)
+      end
+
+      def test_deleted
+        branch = Branch.new(1,2,3)
+
+        branch.deleted!
+        assert(branch.deleted?)
+
+        branch.success!
+        refute(branch.deleted?)
+      end
+
+      def test_unknown
+        branch = Branch.new(1,2,3)
+
+        branch.unknown!
+        assert(branch.unknown?)
+
+        branch.success!
+        refute(branch.unknown?)
+      end
+
+      private
+
+      def branch_hash
+        @branch_hash ||= {
+            'ref' => 'branch 1',
+            'remote_url' => 'the_origin_url',
+            'remote' => 'origin',
+            'sha' => 'random_sha',
+            'status' => 'success',
+            'resolutions' => {},
+            'stories' => ['123'],
+            'metadata' => {
+                'some' => 'data'
+            },
+            'updated_at' => Time.now - 1000,
+            'created_at' => Time.now - 1000,
+        }
+      end
+    end
+  end
+end

data/test/lib/data/test_collection.rb

@@ -0,0 +1,238 @@
+require 'minitest_helper'
+
+module FlashFlow
+  module Data
+    class TestCollection < Minitest::Test
+
+      def setup_fake_branches
+        Object.send(:remove_const, :FakeBranches) if Object.const_defined?(:FakeBranches)
+
+        fake_branches_class = Class.new do
+          @branches = Minitest::Mock.new
+          def self.new(opts=nil); @branches; end
+          def self.branches; @branches; end
+        end
+        Object.const_set('FakeBranches', fake_branches_class)
+      end
+
+      def setup
+        setup_fake_branches
+        @fake_branches = FakeBranches.branches
+        @branch = Branch.new('origin', 'the_origin_url', 'some_branch')
+        @collection = Collection.new({ 'origin' => 'the_origin_url' }, { 'class' => { 'name' => 'FakeBranches' }})
+      end
+
+      def test_from_hash_set_branches
+        hash = { 'some_url/some_branch' => Branch.new('origin', 'the_origin_url', 'some_branch') }
+        assert_equal(Collection.from_hash({}, hash).branches, hash)
+      end
+
+      def test_from_hash_set_remotes
+        remotes = { 'some_remote' => 'some_remote_url' }
+        assert_equal(Collection.from_hash(remotes, {}).remotes, remotes)
+      end
+
+      def test_fetch_calls_collection_class
+        @fake_branches.expect(:fetch, [], [])
+        @collection.fetch
+
+        @fake_branches.verify
+      end
+
+      def test_fetch_returns_nil_if_no_collection_class
+        assert_nil(@collection.fetch)
+      end
+
+      def test_fetch_maps_collection_class_to_branches
+        branch = Data::Branch.new('origin', 'the_origin_url', 'some_branch')
+        @fake_branches.expect(:fetch, [Branch.from_hash({'remote' => branch.remote, 'remote_url' => branch.remote_url, 'ref' => branch.ref })], [])
+        @collection.fetch
+
+        assert_equal(@collection.branches.values, [branch])
+        @fake_branches.verify
+      end
+
+      def test_fetch_finds_the_remote
+        branch = Data::Branch.new('origin', 'the_origin_url', 'some_branch')
+        @fake_branches.expect(:fetch, [Branch.from_hash({'remote_url' => branch.remote_url, 'ref' => branch.ref })], [])
+        @collection.fetch
+
+        assert_equal(@collection.branches.values, [branch])
+        @fake_branches.verify
+      end
+
+      def test_reverse_merge_when_old_is_empty
+        @collection.mark_success(@branch)
+
+        merged = @collection.reverse_merge(Collection.from_hash({}, {}))
+        assert_equal(['the_origin_url/some_branch'], merged.to_h.keys)
+        assert(merged.get('the_origin_url', 'some_branch').success?)
+      end
+
+      def test_reverse_merge_old_marks_old_branches
+        @collection.mark_success(@branch)
+
+        merged = @collection.reverse_merge(Collection.from_hash({}, old_branches))
+        assert(merged.get('the_origin_url', 'some_old_branch').unknown?)
+      end
+
+      def test_reverse_merge_old_adds_new_stories
+        @collection.mark_success(@branch)
+        @collection.add_story('origin', 'some_branch', '456')
+        merged = @collection.reverse_merge(Collection.from_hash({}, old_branches))
+
+        assert_equal(['222', '456'], merged.get('the_origin_url', 'some_branch').stories)
+      end
+
+      def test_reverse_merge_old_uses_old_created_at
+        @collection.add_to_merge('origin', 'some_old_branch')
+        @collection.add_to_merge('origin', 'some_new_branch')
+        old_branch_collection = Collection.from_hash({}, old_branches)
+        merged = @collection.reverse_merge(old_branch_collection)
+
+        assert_equal(old_branch_collection.get('the_origin_url', 'some_branch').created_at, merged.get('the_origin_url', 'some_branch').created_at)
+        # Assert the new branch is created_at within the last minute
+        assert(merged.get('the_origin_url', 'some_new_branch').created_at > (Time.now - 60))
+      end
+
+      def test_reverse_merge_old_uses_new_status
+        @collection.mark_failure(old_branches['the_origin_url/some_branch'])
+        merged = @collection.reverse_merge(Collection.from_hash({}, old_branches))
+
+        assert(merged.get('the_origin_url', 'some_branch').fail?)
+      end
+
+      def test_fetch_returns_a_collection_instance
+        FakeBranches.branches.expect(:fetch, [])
+        collection = Collection.fetch({ 'origin' => 'the_origin_url' }, { 'class' => { 'name' => 'FakeBranches' }})
+        assert(collection.is_a?(Collection))
+      end
+
+      def test_add_to_merge_new_branch
+        @collection.add_to_merge('origin', 'some_branch')
+        assert_equal(@collection.get('the_origin_url', 'some_branch').ref, 'some_branch')
+        assert_equal(@collection.get('the_origin_url', 'some_branch').remote, 'origin')
+        assert_equal(@collection.get('the_origin_url', 'some_branch').remote_url, 'the_origin_url')
+      end
+
+      def test_add_to_merge_existing_branch
+        @collection.mark_failure(@branch)
+        @collection.add_to_merge(@branch.remote, @branch.ref)
+
+        assert_equal(@collection.get(@branch.remote_url, @branch.ref), @branch)
+      end
+
+      def test_add_to_merge_calls_branches_class
+        @fake_branches.expect(:add_to_merge, true, [@branch])
+        @collection.add_to_merge(@branch.remote, @branch.ref)
+
+        @fake_branches.verify
+      end
+
+      def test_remove_from_merge_new_branch
+        @collection.remove_from_merge(@branch.remote, @branch.ref)
+        assert(@collection.get(@branch.remote_url, @branch.ref).removed?)
+      end
+
+      def test_remove_from_merge_existing_branch
+        @collection.mark_success(@branch)
+        assert(@collection.get(@branch.remote_url, @branch.ref).success?)
+        @collection.remove_from_merge(@branch.remote, @branch.ref)
+        assert(@collection.get(@branch.remote_url, @branch.ref).removed?)
+      end
+
+      def test_remove_from_merge_calls_branches_class
+        @fake_branches.expect(:remove_from_merge, true, [@branch])
+        @collection.remove_from_merge(@branch.remote, @branch.ref)
+        @fake_branches.verify
+      end
+
+      def test_mark_success_new_branch
+        @collection.mark_success(@branch)
+        assert(@collection.get(@branch.remote_url, @branch.ref).success?)
+      end
+
+      def test_mark_success_existing_branch
+        branch = @collection.add_to_merge(@branch.remote, @branch.ref)
+        @collection.mark_failure(branch)
+        @collection.mark_success(branch)
+        assert(@collection.get(@branch.remote_url, @branch.ref).success?)
+      end
+
+      def test_mark_success_calls_branches_class
+        @fake_branches.expect(:mark_success, true, [@branch])
+        @collection.mark_success(@branch)
+        @fake_branches.verify
+      end
+
+      def test_mark_failure_existing_branch
+        branch = @collection.add_to_merge(@branch.remote, @branch.ref)
+        @collection.mark_success(branch)
+        @collection.mark_failure(branch)
+        assert(@collection.get(@branch.remote_url, @branch.ref).fail?)
+      end
+
+      def test_mark_failure_new_branch
+        @collection.mark_failure(@branch)
+        assert(@branch.fail?)
+      end
+
+      def test_mark_failure_calls_branches_class
+        @fake_branches.expect(:mark_failure, true, [@branch])
+        @collection.mark_failure(@branch)
+        @fake_branches.verify
+      end
+
+      def test_mark_deleted_new_branch
+        @collection.mark_deleted(@branch)
+        assert(@collection.get(@branch.remote_url, @branch.ref).deleted?)
+      end
+
+      def test_mark_deleted_existing_branch
+        branch = @collection.add_to_merge(@branch.remote, @branch.ref)
+        @collection.mark_failure(branch)
+        @collection.mark_deleted(branch)
+        assert(@collection.get(@branch.remote_url, @branch.ref).deleted?)
+      end
+
+      def test_mark_deleted_calls_branches_class
+        @fake_branches.expect(:mark_deleted, true, [@branch])
+        @collection.mark_deleted(@branch)
+        @fake_branches.verify
+      end
+
+      def test_add_story
+        @collection.add_to_merge('origin', 'some_branch')
+        @collection.add_story('origin', 'some_branch', '999')
+        assert_equal(@collection.get('the_origin_url', 'some_branch').stories, ['999'])
+      end
+
+      def test_add_story_calls_branches_class
+        @fake_branches.expect(:add_story, true, [@branch, '999'])
+        @collection.add_to_merge('origin', 'some_branch')
+        @collection.add_story('origin', 'some_branch', '999')
+        @fake_branches.verify
+      end
+
+      def test_failures
+        branch1 = Branch.new('111', '111', '111')
+        branch2 = Branch.new('222', '222', '222')
+        branch3 = Branch.new('333', '333', '333')
+        @collection.mark_failure(branch1)
+        @collection.mark_success(branch2)
+        @collection.mark_failure(branch3)
+
+        assert_equal(@collection.failures.values, [branch1, branch3])
+      end
+
+      private
+
+      def old_branches
+        @old_branches ||= {
+            'the_origin_url/some_old_branch' => Branch.from_hash({'ref' => 'some_old_branch', 'remote_url' => 'the_origin_url', 'remote' => 'origin', 'created_at' => (Time.now - 3600), 'stories' => ['111']}),
+            'the_origin_url/some_branch' => Branch.from_hash({'ref' => 'some_branch', 'remote_url' => 'the_origin_url', 'remote' => 'origin', 'status' => 'success', 'created_at' => (Time.now - 1800), 'stories' => ['222']})
+        }
+      end
+    end
+  end
+end