paradeiser 0.4.0 → 0.5.0

data/test/unit/test_pomodori_view.rb

@@ -1,41 +1,44 @@
 require 'helper'
 
-class TestPomodoriView < ViewTest
-  def setup
-    @pom = produce(Pomodoro)
-    @pom.id = 1
-  end
-
-  def test_start
-    assert_match(/^Started pomodoro #1\.$/m, render(:start))
-  end
-
-  def test_finish
-    assert_match(/^Finished pomodoro #1 after .* minutes\.$/m, render(:finish))
-  end
-
-  def test_cancel
-    cancel!
-    assert_match(/^Canceled pomodoro #1 after .* minutes\.$/m, render(:cancel))
-  end
-
-  def test_interrupt_internal
-    @interrupt_type = 'internally'
-    assert_match(/^Marked pomodoro #1 as internally interrupted\.$/m, render(:interrupt))
-  end
-
-  def test_interrupt_external
-    @interrupt_type = 'externally'
-    assert_match(/^Marked pomodoro #1 as externally interrupted\.$/m, render(:interrupt))
-  end
-
-  def test_annotate
-    assert_match(/^Successfully annotated pomodoro #1\.$/m, render(:annotate))
-  end
-
-protected
-
-  def model
-    'Pomodoro'
+module ParadeiserTest
+  class TestPomodoriView < ViewTest
+    def setup
+      super
+      @pom = produce(Pomodoro)
+      @pom.id = 1
+    end
+
+    def test_start
+      assert_match(/^Started pomodoro #1\.$/m, render(:start))
+    end
+
+    def test_finish
+      assert_match(/^Finished pomodoro #1 after .* minutes\.$/m, render(:finish))
+    end
+
+    def test_cancel
+      cancel!
+      assert_match(/^Canceled pomodoro #1 after .* minutes\.$/m, render(:cancel))
+    end
+
+    def test_interrupt_internal
+      @interrupt_type = 'internally'
+      assert_match(/^Marked pomodoro #1 as internally interrupted\.$/m, render(:interrupt))
+    end
+
+    def test_interrupt_external
+      @interrupt_type = 'externally'
+      assert_match(/^Marked pomodoro #1 as externally interrupted\.$/m, render(:interrupt))
+    end
+
+    def test_annotate
+      assert_match(/^Successfully annotated pomodoro #1\.$/m, render(:annotate))
+    end
+
+  protected
+
+    def model
+      'Pomodoro'
+    end
   end
 end

data/test/unit/test_pomodoro.rb

@@ -1,164 +1,167 @@
 require 'helper'
 
-class TestPomodoro < MiniTest::Test
-  def setup
-    @pom = produce(Pomodoro)
-  end
-
-  def test_finish_active
-    assert_equal(:active, @pom.status_name)
+module ParadeiserTest
+  class TestPomodoro < UnitTest
+    def setup
+      super
+      @pom = produce(Pomodoro)
+    end
 
-    now = srand
+    def test_finish_active
+      assert_equal(:active, @pom.status_name)
 
-    Time.stub :now, Time.at(now) do
-      finish!
-    end
+      now = srand
 
-    assert_equal(:finished, @pom.status_name)
-    assert_equal(now, @pom.finished_at.to_i)
-    refute(@pom.canceled_at)
-  end
+      Time.stub :now, Time.at(now) do
+        finish!
+      end
 
-  def test_finish_finished
-    finish!
-    assert_raises StateMachine::InvalidTransition do
-      finish!
+      assert_equal(:finished, @pom.status_name)
+      assert_equal(now, @pom.finished_at.to_i)
+      refute(@pom.canceled_at)
     end
-    refute(@pom.canceled_at)
-  end
 
-  def test_finish_canceled
-    cancel!
-    assert_raises StateMachine::InvalidTransition do
+    def test_finish_finished
       finish!
+      assert_raises StateMachine::InvalidTransition do
+        finish!
+      end
+      refute(@pom.canceled_at)
     end
-    refute(@pom.finished_at)
-  end
-
-  def test_length
-    assert_equal(25 * 60, @pom.length)
-  end
 
-  def test_duration_started
-    later = @started + rand(42)
+    def test_finish_canceled
+      cancel!
+      assert_raises StateMachine::InvalidTransition do
+        finish!
+      end
+      refute(@pom.finished_at)
+    end
 
-    Time.stub :now, Time.at(later) do
-      assert_equal(later - @started, @pom.duration)
+    def test_length
+      assert_equal(25 * 60, @pom.length)
     end
-  end
 
-  def test_duration_finished
-    later = @started + rand(42)
+    def test_duration_started
+      later = @started + rand(42)
 
-    Time.stub :now, Time.at(later) do
-      finish!
+      Time.stub :now, Time.at(later) do
+        assert_equal(later - @started, @pom.duration)
+      end
     end
 
-    assert_equal(later - @started, @pom.duration)
-  end
+    def test_duration_finished
+      later = @started + rand(42)
 
-  def test_duration_canceled
-    later = @started + rand(42)
+      Time.stub :now, Time.at(later) do
+        finish!
+      end
 
-    Time.stub :now, Time.at(later) do
-      cancel!
+      assert_equal(later - @started, @pom.duration)
     end
 
-    assert_equal(later - @started, @pom.duration)
-  end
+    def test_duration_canceled
+      later = @started + rand(42)
 
-  def test_start
-    assert_equal(:active, @pom.status_name)
-    assert_equal(@started, @pom.started_at.to_i)
-  end
+      Time.stub :now, Time.at(later) do
+        cancel!
+      end
 
-  def test_remaining_active
-    Time.stub :now, Time.at(@started) do
-      assert_equal(Pomodoro::MINUTES_25 * 60, @pom.remaining)
+      assert_equal(later - @started, @pom.duration)
     end
 
-    delta = 600
-    later = @started + delta
-
-    Time.stub :now, Time.at(later) do
-      assert_equal(Pomodoro::MINUTES_25 * 60 - delta, @pom.remaining)
+    def test_start
+      assert_equal(:active, @pom.status_name)
+      assert_equal(@started, @pom.started_at.to_i)
     end
-  end
 
-  def test_interrupt
-    assert_equal(0, @pom.interrupts.size)
+    def test_remaining_active
+      Time.stub :now, Time.at(@started) do
+        assert_equal(Pomodoro::MINUTES_25 * 60, @pom.remaining)
+      end
 
-    now = srand
+      delta = 600
+      later = @started + delta
 
-    Time.stub :now, Time.at(now) do
-      interrupt!
+      Time.stub :now, Time.at(later) do
+        assert_equal(Pomodoro::MINUTES_25 * 60 - delta, @pom.remaining)
+      end
     end
 
-    assert_equal(1, @pom.interrupts.size)
+    def test_interrupt
+      assert_equal(0, @pom.interrupts.size)
 
-    int = @pom.interrupts.first
-    assert_equal(now, int.created_at.to_i)
-    assert_equal(:internal, int.type)
-  end
+      now = srand
 
-  def test_interrupt_internal
-    interrupt!(:internal)
-    assert_equal(1, @pom.interrupts.size)
-    int = @pom.interrupts.first
-    assert_equal(:internal, int.type)
-  end
+      Time.stub :now, Time.at(now) do
+        interrupt!
+      end
 
-  def test_interrupt_external
-    interrupt!(:external)
-    assert_equal(1, @pom.interrupts.size)
-    int = @pom.interrupts.first
-    assert_equal(:external, int.type)
-  end
+      assert_equal(1, @pom.interrupts.size)
 
-  def test_interrupt_unknown
-    assert_raises InvalidTypeError do
-      interrupt!(:unknown)
+      int = @pom.interrupts.first
+      assert_equal(now, int.created_at.to_i)
+      assert_equal(:internal, int.type)
     end
-  end
 
-  def test_interrupt_finished
-    finish!
-    assert_raises StateMachine::InvalidTransition do
-      interrupt!
+    def test_interrupt_internal
+      interrupt!(:internal)
+      assert_equal(1, @pom.interrupts.size)
+      int = @pom.interrupts.first
+      assert_equal(:internal, int.type)
     end
-  end
 
-  def test_interrupt_canceled
-    cancel!
-    assert_raises StateMachine::InvalidTransition do
-      interrupt!
+    def test_interrupt_external
+      interrupt!(:external)
+      assert_equal(1, @pom.interrupts.size)
+      int = @pom.interrupts.first
+      assert_equal(:external, int.type)
     end
-  end
 
-  def test_cancel_active
-    assert_equal(:active, @pom.status_name)
+    def test_interrupt_unknown
+      assert_raises InvalidTypeError do
+        interrupt!(:unknown)
+      end
+    end
 
-    now = srand
+    def test_interrupt_finished
+      finish!
+      assert_raises StateMachine::InvalidTransition do
+        interrupt!
+      end
+    end
 
-    Time.stub :now, Time.at(now) do
+    def test_interrupt_canceled
       cancel!
+      assert_raises StateMachine::InvalidTransition do
+        interrupt!
+      end
     end
 
-    assert_equal(:canceled, @pom.status_name)
-    assert_equal(now, @pom.canceled_at.to_i)
-    refute(@pom.finished_at)
-  end
+    def test_cancel_active
+      assert_equal(:active, @pom.status_name)
 
-  def test_annotate_active
-    annotations = @pom.annotations
-    assert(annotations)
-    assert_empty(annotations)
+      now = srand
 
-    text = 'foobar something'
-    @pom.annotate(text)
+      Time.stub :now, Time.at(now) do
+        cancel!
+      end
 
-    assert_equal(:active, @pom.status_name)
-    refute_empty(@pom.annotations)
-    assert_equal(text, @pom.annotations.first)
+      assert_equal(:canceled, @pom.status_name)
+      assert_equal(now, @pom.canceled_at.to_i)
+      refute(@pom.finished_at)
+    end
+
+    def test_annotate_active
+      annotations = @pom.annotations
+      assert(annotations)
+      assert_empty(annotations)
+
+      text = 'foobar something'
+      @pom.annotate(text)
+
+      assert_equal(:active, @pom.status_name)
+      refute_empty(@pom.annotations)
+      assert_equal(text, @pom.annotations.first)
+    end
   end
 end

data/test/unit/test_pomodoro_hooks.rb

@@ -1,218 +1,220 @@
 require 'helper'
-require 'tmpdir'
-
-class TestPomodoroHooks < MiniTest::Test
-  def setup
-    # Cannot use fakefs because hooks will not execute under it, but as part of
-    # the real FS. Instead, we set the $PAR_DIR to point to a temp directory
-    @orig_PAR_DIR = ENV['PAR_DIR']
-    ENV['PAR_DIR'] = Dir.mktmpdir
-  end
-
-  def teardown
-    FileUtils.rm_rf(Paradeiser.par_dir)
-    ENV['PAR_DIR'] = @orig_PAR_DIR
-  end
 
-  def test_before_start_pomodoro_success
-    hook_name = 'before-start-pomodoro'
-    token_file = create_hook('Pomodoro', hook_name)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
-    pom = produce(Pomodoro)
-    assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:active, pom.status_name)
-    assert_match(/Pomodoro \d \d{1,2}:\d{1,2}/ , File.read(token_file).chomp)
-  end
+module ParadeiserTest
+  class TestPomodoroHooks < UnitTest
+    def setup
+      super
+      @token_file_registry = TokenFileRegistry.new
+    end
 
-  def test_before_finish_pomodoro_success
-    hook_name = 'before-finish-pomodoro'
-    pom = produce(Pomodoro)
-    pom.id = SecureRandom.random_number(1000)
-    token_file = create_hook('Pomodoro', hook_name)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
-    pom.finish
-    assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:finished, pom.status_name)
-    assert_equal("Pomodoro #{pom.id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
-  end
+    def teardown
+      if passed?
+        @token_file_registry.cleanup
+        super
+      end
+    end
 
-  def test_before_finish_pomodoro_error
-    hook_name = 'before-finish-pomodoro'
-    pom = produce(Pomodoro)
-    pom.id = SecureRandom.random_number(1000)
-    token_file = create_hook('Pomodoro', hook_name, false)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+    def test_before_start_pomodoro_success
+      hook_name = 'before-start-pomodoro'
+      token_file = create_hook('Pomodoro', hook_name)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+      pom = produce(Pomodoro)
+      assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:active, pom.status_name)
+      assert_match(/^Pomodoro \d+ $/, File.read(token_file).chomp, "Token file: #{token_file}")
+    end
 
-    assert_raises HookFailedError do
+    def test_before_finish_pomodoro_success
+      hook_name = 'before-finish-pomodoro'
+      pom = produce(Pomodoro)
+      pom.id = SecureRandom.random_number(1000)
+      token_file = create_hook('Pomodoro', hook_name)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
       pom.finish
+      assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:finished, pom.status_name)
+      assert_equal("Pomodoro #{pom.id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
     end
 
-    refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:active, pom.status_name)
-  end
+    def test_before_finish_pomodoro_error
+      hook_name = 'before-finish-pomodoro'
+      pom = produce(Pomodoro)
+      pom.id = SecureRandom.random_number(1000)
+      token_file = create_hook('Pomodoro', hook_name, false)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
 
-  def test_before_finish_break_success
-    hook_name = 'before-finish-break'
-    br3ak = Break.new
-    br3ak.id = SecureRandom.random_number(1000)
-    token_file = create_hook('Break', hook_name)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
-    br3ak.finish
-    assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:finished, br3ak.status_name)
-    assert_equal("Break #{br3ak.id} #{br3ak.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
-  end
+      assert_raises HookFailedError do
+        pom.finish
+      end
 
-  def test_before_finish_break_error
-    hook_name = 'before-finish-break'
-    br3ak = Break.new
-    br3ak.id = SecureRandom.random_number(1000)
-    token_file = create_hook('Break', hook_name, false)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+      refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:active, pom.status_name)
+    end
 
-    assert_raises HookFailedError do
+    def test_before_finish_break_success
+      hook_name = 'before-finish-break'
+      br3ak = Break.new
+      br3ak.id = SecureRandom.random_number(1000)
+      token_file = create_hook('Break', hook_name)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
       br3ak.finish
+      assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:finished, br3ak.status_name)
+      assert_equal("Break #{br3ak.id} #{br3ak.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
     end
 
-    refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:active, br3ak.status_name)
-  end
+    def test_before_finish_break_error
+      hook_name = 'before-finish-break'
+      br3ak = Break.new
+      br3ak.id = SecureRandom.random_number(1000)
+      token_file = create_hook('Break', hook_name, false)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
 
-  def test_before_interrupt_success
-    hook_name = 'before-interrupt-pomodoro'
-    pom = produce(Pomodoro)
-    token_file = create_hook('Pomodoro', hook_name)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
-    pom.interrupt
-    assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:active, pom.status_name)
-    assert_equal("Pomodoro #{Repository.next_id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
-  end
+      assert_raises HookFailedError do
+        br3ak.finish
+      end
 
-  def test_before_interrupt_error
-    hook_name = 'before-interrupt-pomodoro'
-    pom = produce(Pomodoro)
-    token_file = create_hook('Pomodoro', hook_name, false)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+      refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:active, br3ak.status_name)
+    end
 
-    assert_raises HookFailedError do
+    def test_before_interrupt_success
+      hook_name = 'before-interrupt-pomodoro'
+      pom = produce(Pomodoro)
+      token_file = create_hook('Pomodoro', hook_name)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
       pom.interrupt
+      assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:active, pom.status_name)
+      assert_equal("Pomodoro #{Repository.next_id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
     end
 
-    refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:active, pom.status_name)
-  end
+    def test_before_interrupt_error
+      hook_name = 'before-interrupt-pomodoro'
+      pom = produce(Pomodoro)
+      token_file = create_hook('Pomodoro', hook_name, false)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
 
-  def test_after_interrupt_success
-    hook_name = 'after-interrupt-pomodoro'
-    pom = produce(Pomodoro)
-    token_file = create_hook('Pomodoro', hook_name, false)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+      assert_raises HookFailedError do
+        pom.interrupt
+      end
 
-    assert_raises HookFailedError do
-      pom.interrupt
+      refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:active, pom.status_name)
     end
 
-    refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:active, pom.status_name)
-  end
+    def test_after_interrupt_success
+      hook_name = 'after-interrupt-pomodoro'
+      pom = produce(Pomodoro)
+      token_file = create_hook('Pomodoro', hook_name, false)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
 
-  def test_after_interrupt_error
-    hook_name = 'after-interrupt-pomodoro'
-    pom = produce(Pomodoro)
-    token_file = create_hook('Pomodoro', hook_name)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
-    pom.interrupt
-    assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:active, pom.status_name)
-    assert_equal("Pomodoro #{Repository.next_id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
-  end
+      assert_raises HookFailedError do
+        pom.interrupt
+      end
 
-  def test_before_cancel_success
-    hook_name = 'before-cancel-pomodoro'
-    pom = produce(Pomodoro)
-    token_file = create_hook('Pomodoro', hook_name)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
-    pom.cancel
-    assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:canceled, pom.status_name)
-    assert_equal("Pomodoro #{Repository.next_id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
-  end
+      refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:active, pom.status_name)
+    end
 
-  def test_before_cancel_error
-    hook_name = 'before-cancel-pomodoro'
-    pom = produce(Pomodoro)
-    token_file = create_hook('Pomodoro', hook_name, false)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+    def test_after_interrupt_error
+      hook_name = 'after-interrupt-pomodoro'
+      pom = produce(Pomodoro)
+      token_file = create_hook('Pomodoro', hook_name)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+      pom.interrupt
+      assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:active, pom.status_name)
+      assert_equal("Pomodoro #{Repository.next_id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
+    end
 
-    assert_raises HookFailedError do
+    def test_before_cancel_success
+      hook_name = 'before-cancel-pomodoro'
+      pom = produce(Pomodoro)
+      token_file = create_hook('Pomodoro', hook_name)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
       pom.cancel
+      assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:canceled, pom.status_name)
+      assert_equal("Pomodoro #{Repository.next_id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
     end
 
-    refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:active, pom.status_name)
-  end
+    def test_before_cancel_error
+      hook_name = 'before-cancel-pomodoro'
+      pom = produce(Pomodoro)
+      token_file = create_hook('Pomodoro', hook_name, false)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
 
-  def test_after_cancel_success
-    hook_name = 'after-cancel-pomodoro'
-    pom = produce(Pomodoro)
-    token_file = create_hook('Pomodoro', hook_name, false)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+      assert_raises HookFailedError do
+        pom.cancel
+      end
 
-    assert_raises HookFailedError do
-      pom.cancel
+      refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:active, pom.status_name)
     end
 
-    refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:canceled, pom.status_name)
-  end
+    def test_after_cancel_success
+      hook_name = 'after-cancel-pomodoro'
+      pom = produce(Pomodoro)
+      token_file = create_hook('Pomodoro', hook_name, false)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
 
-  def test_after_cancel_error
-    hook_name = 'after-cancel-pomodoro'
-    pom = produce(Pomodoro)
-    token_file = create_hook('Pomodoro', hook_name)
-    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
-    pom.cancel
-    assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
-    assert_equal(:canceled, pom.status_name)
-    assert_equal("Pomodoro #{Repository.next_id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
-  end
+      assert_raises HookFailedError do
+        pom.cancel
+      end
 
-private
+      refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:canceled, pom.status_name)
+    end
+
+    def test_after_cancel_error
+      hook_name = 'after-cancel-pomodoro'
+      pom = produce(Pomodoro)
+      token_file = create_hook('Pomodoro', hook_name)
+      refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+      pom.cancel
+      assert_path_exists(token_file, "#{hook_name} hook should have created a token file")
+      assert_equal(:canceled, pom.status_name)
+      assert_equal("Pomodoro #{Repository.next_id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
+    end
+
+  private
 
-  def create_hook(thing, hook_name, hook_succeeds = true)
-    token_file = File.join(Dir.tmpdir, SecureRandom.uuid)
+    def create_hook(thing, hook_name, hook_succeeds = true)
+      token_file = @token_file_registry.create
 
-    hooks_dir = Paradeiser.hooks_dir
-    FileUtils.mkdir(hooks_dir)
+      hooks_dir = Paradeiser.hooks_dir
+      FileUtils.mkdir(hooks_dir)
 
-    hook_file = File.join(hooks_dir, hook_name)
+      hook_file = File.join(hooks_dir, hook_name)
 
-    File.open(hook_file, 'w') do |f|
-      if hook_succeeds
-        f.write(hook_contents_success(thing, token_file))
-      else
-        f.write(hook_contents_failure)
+      File.open(hook_file, 'w') do |f|
+        if hook_succeeds
+          f.write(hook_contents_success(thing, token_file))
+        else
+          f.write(hook_contents_failure)
+        end
       end
-    end
 
-    File.chmod(0700, hook_file)
+      File.chmod(0700, hook_file)
 
-    assert(File.exist?(hook_file))
-    token_file
-  end
+      assert(File.exist?(hook_file), "Hook #{hook_file} must exist")
+      assert(File.executable?(hook_file), "Hook #{hook_file} must be executable")
+      token_file
+    end
 
-  def hook_contents_success(thing, token_file)
-    hook_contents =<<"EOF"
-#!/bin/sh
-echo "#{thing} $PAR_#{thing.upcase}_ID $PAR_#{thing.upcase}_STARTED_AT" > #{token_file}
-EOF
-  end
+    def hook_contents_success(thing, token_file)
+      <<~EOF
+        #!/bin/sh
+        echo "#{thing} $PAR_#{thing.upcase}_ID $PAR_#{thing.upcase}_STARTED_AT" > #{token_file}
+      EOF
+    end
 
-  def hook_contents_failure
-    hook_contents =<<"EOF"
-#!/bin/sh
-exit 1
-EOF
+    def hook_contents_failure
+      <<~EOF
+        #!/bin/sh
+        exit 1
+      EOF
+    end
   end
 end