paradeiser 0.1.0 → 0.2.0

data/test/unit/test_pomodori_controller.rb

@@ -6,7 +6,7 @@ class TestPomodoriController < MiniTest::Test
   end
 
   def test_start
-    pom, has_output = invoke(:start, '@pom', 'has_output')
+    pom, has_output = invoke(:start, nil, '@pom', 'has_output')
     assert_equal(:active, pom.status_name)
     assert_equal(false, has_output)
     assert_equal(1, @backend.size)
@@ -24,80 +24,136 @@ class TestPomodoriController < MiniTest::Test
 
   def test_finish
     invoke(:start)
-    pom, has_output = invoke(:finish, '@pom', 'has_output')
+    pom, has_output = invoke(:finish, nil, '@pom', 'has_output')
     assert_equal(:finished, pom.status_name)
     assert_equal(false, has_output)
     assert_equal(1, @backend.size)
   end
 
   def test_finish_idle
-    assert_raises NoActivePomodoroError do
+    assert_raises NotActiveError do
       invoke(:finish)
     end
     assert_equal(0, @backend.size)
   end
 
-  def test_report_idle
-    pomodori, has_output = invoke(:report, '@pom', 'has_output')
-    assert_empty(pomodori)
-    assert_equal(true, has_output)
+  def test_finish_canceled
+    invoke(:start)
+    invoke(:cancel)
+    assert_equal(1, @backend.size)
+
+    assert_raises NotActiveError do
+      invoke(:finish)
+    end
+    assert_equal(1, @backend.size)
+    assert_equal(:canceled, @backend[@backend.roots.first].status_name)
+  end
+
+  def test_interrupt_idle
+    assert_raises NotActiveError do
+      invoke(:interrupt)
+    end
+    assert_equal(0, @backend.size)
   end
 
-  def test_report_active
+  def test_interrupt_active
     invoke(:start)
-    pomodori, has_output = invoke(:report, '@pom', 'has_output')
-    assert_equal(1, pomodori.size)
-    assert_equal(true, has_output)
+    pom, has_output = invoke(:interrupt, OpenStruct.new, '@pom', 'has_output')
+    assert_equal(:active, pom.status_name)
+
+    interrupts = pom.interrupts
+    refute_nil(interrupts)
+    refute_empty(interrupts)
+    assert_equal(1, interrupts.size)
+
+    interrupt = interrupts.first
+    refute_nil(interrupt)
+    refute_nil(interrupt.created_at)
+    assert_equal(:internal, interrupt.type)
   end
 
-  def test_report_finished
+  def test_interrupt_active_internal
     invoke(:start)
-    invoke(:finish)
+    pom = invoke(:interrupt, OpenStruct.new(:internal => true), '@pom')
+    interrupt = pom.interrupts.first
+    assert_equal(:internal, interrupt.type)
+  end
+
+  def test_interrupt_active_external
     invoke(:start)
-    pomodori, has_output = invoke(:report, '@pom', 'has_output')
-    assert_equal(2, pomodori.size)
-    assert_equal(true, has_output)
+    pom = invoke(:interrupt, OpenStruct.new(:external => true), '@pom')
+    interrupt = pom.interrupts.first
+    assert_equal(:external, interrupt.type)
+  end
+
+  def test_interrupt_finished
+    invoke(:start)
+    invoke(:finish)
+    assert_equal(1, @backend.size)
+
+    assert_raises NotActiveError do
+      invoke(:interrupt)
+    end
+
+    assert_equal(1, @backend.size)
   end
 
-  def test_status_idle
-    pom, has_output = invoke(:status, '@pom', 'has_output')
-    assert_equal(:idle, pom.status_name)
-    assert_equal(true, has_output)
+  def test_cancel_idle
+    assert_raises NotActiveError do
+      invoke(:cancel)
+    end
     assert_equal(0, @backend.size)
   end
 
-  def test_status_active
+  def test_cancel_active
     invoke(:start)
-    pom, has_output = invoke(:status, '@pom', 'has_output')
-    assert_equal(:active, pom.status_name)
-    assert_equal(true, has_output)
+    pom, has_output = invoke(:cancel, nil, '@pom', 'has_output')
+    assert_equal(:canceled, pom.status_name)
+    assert_equal(false, has_output)
     assert_equal(1, @backend.size)
   end
 
-  def test_status_finished
+  def test_cancel_finished
     invoke(:start)
     invoke(:finish)
-    pom, has_output = invoke(:status, '@pom', 'has_output')
-    assert_equal(:finished, pom.status_name)
-    assert_equal(true, has_output)
     assert_equal(1, @backend.size)
+
+    assert_raises NotActiveError do
+      invoke(:cancel)
+    end
+
+    assert_equal(1, @backend.size)
+  end
+
+  def test_cancel_again
+    invoke(:start)
+    invoke(:cancel)
+    assert_equal(1, @backend.size)
+    invoke(:start)
+    assert_equal(2, @backend.size)
   end
 
 private
 
-  def invoke(method, *attributes)
+  def invoke(method, options = nil, *attributes)
     controller = PomodoriController.new(method)
 
     Repository.stub :backend, @backend do
       Scheduler.stub(:add, nil) do
         Scheduler.stub(:clear, nil) do
-          controller.call(nil, nil)
+          controller.call(nil, options)
         end
       end
     end
 
-    attributes.map do |attribute|
+    result = attributes.map do |attribute|
       controller.get_binding.eval(attribute)
     end
+
+    if 1 == result.size
+      result.first
+    else
+      result
+    end
   end
 end

data/test/unit/test_pomodori_view.rb

@@ -6,56 +6,6 @@ class TestPomodoriView < MiniTest::Test
     @pom.id = 1
   end
 
-  def test_status_idle
-    out, err = render(:status)
-    assert_match(/^Current state is idle.$/m, out)
-    assert_empty(err)
-  end
-
-  def test_status_active
-    start!
-    out, err = render(:status)
-    assert_match(/^Pomodoro #1 is active for another \d{1,2} minutes \(started at .*\)\.$/m, out)
-    assert_empty(err)
-  end
-
-  def test_status_finished
-    start!
-    finish!
-    out, err = render(:status)
-    assert_match(/^No active pomodoro. Last one was finished at .*\.$/m, out)
-    assert_empty(err)
-  end
-
-  def test_report_empty
-    @pom = []
-    out, err = render(:report)
-    assert_equal(1, out.lines.size)
-    assert_match(/^ID \| Status \| Started \| Ended$/m, out.lines.first)
-    assert_empty(err)
-  end
-
-  def test_report_one_active
-    start!
-    @pom = [@pom]
-    out, err = render(:report)
-    assert_equal(2, out.lines.size)
-    assert_match(/^ID \| Status \| Started \| Ended$/m, out.lines[0])
-    assert_match(/^1 \| active \| \d{1,2}:\d{1,2} \| $/m, out.lines[1])
-    assert_empty(err)
-  end
-
-  def test_report_one_finished
-    start!
-    finish!
-    @pom = [@pom]
-    out, err = render(:report)
-    assert_equal(2, out.lines.size)
-    assert_match(/^ID \| Status \| Started \| Ended$/m, out.lines[0])
-    assert_match(/^1 \| finished \| \d{1,2}:\d{1,2} \| \d{1,2}:\d{1,2}$/m, out.lines[1])
-    assert_empty(err)
-  end
-
   def test_start
     out, err = render(:start)
     assert_match(/^Starting pomodoro #1\.$/m, out)

data/test/unit/test_pomodoro.rb

@@ -7,15 +7,21 @@ class TestPomodoro < MiniTest::Test
 
   def test_virgin
     assert_equal(:idle, @pom.status_name)
+    refute(@pom.started_at)
+    refute(@pom.canceled_at)
+    refute(@pom.finished_at)
   end
 
   def test_finish_idle
     assert_raises StateMachine::InvalidTransition do
       finish!
     end
+    refute(@pom.started_at)
+    refute(@pom.canceled_at)
+    refute(@pom.finished_at)
   end
 
-  def test_finish
+  def test_finish_active
     start!
     assert_equal(:active, @pom.status_name)
 
@@ -27,6 +33,29 @@ class TestPomodoro < MiniTest::Test
 
     assert_equal(:finished, @pom.status_name)
     assert_equal(now, @pom.finished_at.to_i)
+    refute(@pom.canceled_at)
+  end
+
+  def test_finish_finished
+    start!
+    finish!
+    assert_raises StateMachine::InvalidTransition do
+      finish!
+    end
+    refute(@pom.canceled_at)
+  end
+
+  def test_finish_canceled
+    start!
+    cancel!
+    assert_raises StateMachine::InvalidTransition do
+      finish!
+    end
+    refute(@pom.finished_at)
+  end
+
+  def test_length
+    assert_equal(25 * 60, @pom.length)
   end
 
   def test_duration_idle
@@ -63,12 +92,20 @@ class TestPomodoro < MiniTest::Test
     assert_equal(later - now, @pom.duration)
   end
 
-  def test_finish_finished
-    start!
-    finish!
-    assert_raises StateMachine::InvalidTransition do
-      finish!
+  def test_duration_canceled
+    now = srand
+
+    Time.stub :now, Time.at(now) do
+      start!
+    end
+
+    later = now + rand(42)
+
+    Time.stub :now, Time.at(later) do
+      cancel!
     end
+
+    assert_equal(later - now, @pom.duration)
   end
 
   def test_start
@@ -82,19 +119,104 @@ class TestPomodoro < MiniTest::Test
     assert_equal(now, @pom.started_at.to_i)
   end
 
-  def test_remaining
+  def test_remaining_active
     now = srand
 
     Time.stub :now, Time.at(now) do
       start!
-      assert_equal(Pomodoro::LENGTH_SECONDS, @pom.remaining)
+      assert_equal(Pomodoro::MINUTES_25 * 60, @pom.remaining)
     end
 
     delta = 600
     later = now + delta
 
     Time.stub :now, Time.at(later) do
-      assert_equal(Pomodoro::LENGTH_SECONDS - delta, @pom.remaining)
+      assert_equal(Pomodoro::MINUTES_25 * 60 - delta, @pom.remaining)
+    end
+  end
+
+  def test_interrupt
+    start!
+    assert_equal(0, @pom.interrupts.size)
+
+    now = srand
+
+    Time.stub :now, Time.at(now) do
+      interrupt!
     end
+
+    assert_equal(1, @pom.interrupts.size)
+
+    int = @pom.interrupts.first
+    assert_equal(now, int.created_at.to_i)
+    assert_equal(:internal, int.type)
+  end
+
+  def test_interrupt_internal
+    start!
+    interrupt!(:internal)
+    assert_equal(1, @pom.interrupts.size)
+    int = @pom.interrupts.first
+    assert_equal(:internal, int.type)
+  end
+
+  def test_interrupt_external
+    start!
+    interrupt!(:external)
+    assert_equal(1, @pom.interrupts.size)
+    int = @pom.interrupts.first
+    assert_equal(:external, int.type)
+  end
+
+  def test_interrupt_unknown
+    start!
+    assert_raises InvalidTypeError do
+      interrupt!(:unknown)
+    end
+  end
+
+  def test_interrupt_idle
+    assert_raises StateMachine::InvalidTransition do
+      interrupt!
+    end
+  end
+
+  def test_interrupt_finished
+    start!
+    finish!
+    assert_raises StateMachine::InvalidTransition do
+      interrupt!
+    end
+  end
+
+  def test_interrupt_canceled
+    start!
+    cancel!
+    assert_raises StateMachine::InvalidTransition do
+      interrupt!
+    end
+  end
+
+  def test_cancel_idle
+    assert_raises StateMachine::InvalidTransition do
+      cancel!
+    end
+    refute(@pom.finished_at)
+    refute(@pom.canceled_at)
+  end
+
+  def test_cancel_active
+    start!
+    assert_equal(:active, @pom.status_name)
+
+    now = srand
+
+    Time.stub :now, Time.at(now) do
+      cancel!
+    end
+
+    assert_equal(:canceled, @pom.status_name)
+    assert_equal(now, @pom.canceled_at.to_i)
+    refute(@pom.finished_at)
   end
 end

data/test/unit/test_pomodoro_hooks.rb

@@ -3,36 +3,47 @@ require 'tmpdir'
 
 class TestPomodoroHooks < MiniTest::Test
   def setup
-    @orig_pom_dir = ENV['POM_DIR']
-    ENV['POM_DIR'] = Dir.mktmpdir
+    # 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.pom_dir)
-    ENV['POM_DIR'] = @orig_pom_dir
+    FileUtils.rm_rf(Paradeiser.par_dir)
+    ENV['PAR_DIR'] = @orig_PAR_DIR
   end
 
-  def test_before_finish_success
-    hook_name = 'before-finish'
+  def test_before_start_pomodoro_success
+    hook_name = 'before-start-pomodoro'
+    pom = Pomodoro.new
+    token_file = create_hook('Pomodoro', hook_name)
+    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+    pom.start
+    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
 
+  def test_before_finish_pomodoro_success
+    hook_name = 'before-finish-pomodoro'
     pom = Pomodoro.new
     pom.id = SecureRandom.random_number(1000)
     pom.start
-    token_file = create_hook(hook_name)
+    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} started #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
+    assert_equal("Pomodoro #{pom.id} #{pom.started_at.strftime('%H:%M')}", File.read(token_file).chomp)
   end
 
-  def test_before_finish_error
-    hook_name = 'before-finish'
-
+  def test_before_finish_pomodoro_error
+    hook_name = 'before-finish-pomodoro'
     pom = Pomodoro.new
     pom.id = SecureRandom.random_number(1000)
     pom.start
-    token_file = create_hook(hook_name, false)
+    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
@@ -43,19 +54,156 @@ class TestPomodoroHooks < MiniTest::Test
     assert_equal(:active, pom.status_name)
   end
 
+  def test_before_finish_break_success
+    hook_name = 'before-finish-break'
+    br3ak = Break.new
+    br3ak.id = SecureRandom.random_number(1000)
+    br3ak.start
+    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
+
+  def test_before_finish_break_error
+    hook_name = 'before-finish-break'
+    br3ak = Break.new
+    br3ak.id = SecureRandom.random_number(1000)
+    br3ak.start
+    token_file = create_hook('Break', hook_name, false)
+    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+
+    assert_raises HookFailedError do
+      br3ak.finish
+    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_interrupt_success
+    hook_name = 'before-interrupt-pomodoro'
+    pom = Pomodoro.new
+    pom.start
+    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
+
+  def test_before_interrupt_error
+    hook_name = 'before-interrupt-pomodoro'
+    pom = Pomodoro.new
+    pom.start
+    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
+
+    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 = Pomodoro.new
+    pom.start
+    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
+
+    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_error
+    hook_name = 'after-interrupt-pomodoro'
+    pom = Pomodoro.new
+    pom.start
+    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
+
+  def test_before_cancel_success
+    hook_name = 'before-cancel-pomodoro'
+    pom = Pomodoro.new
+    pom.start
+    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
+
+  def test_before_cancel_error
+    hook_name = 'before-cancel-pomodoro'
+    pom = Pomodoro.new
+    pom.start
+    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
+
+    refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
+    assert_equal(:active, pom.status_name)
+  end
+
+  def test_after_cancel_success
+    hook_name = 'after-cancel-pomodoro'
+    pom = Pomodoro.new
+    pom.start
+    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
+
+    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 = Pomodoro.new
+    pom.start
+    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(name, hook_succeeds = true)
+  def create_hook(thing, hook_name, hook_succeeds = true)
     token_file = File.join(Dir.tmpdir, SecureRandom.uuid)
 
     hooks_dir = Paradeiser.hooks_dir
     FileUtils.mkdir(hooks_dir)
 
-    hook_file = File.join(hooks_dir, name)
+    hook_file = File.join(hooks_dir, hook_name)
 
     File.open(hook_file, 'w') do |f|
       if hook_succeeds
-        f.write(hook_contents_success(token_file))
+        f.write(hook_contents_success(thing, token_file))
       else
         f.write(hook_contents_failure)
       end
@@ -67,10 +215,10 @@ private
     token_file
   end
 
-  def hook_contents_success(token_file)
+  def hook_contents_success(thing, token_file)
     hook_contents =<<"EOF"
 #!/bin/sh
-echo "Pomodoro $POM_ID started $POM_STARTED_AT" > #{token_file}
+echo "#{thing} $PAR_#{thing.upcase}_ID $PAR_#{thing.upcase}_STARTED_AT" > #{token_file}
 EOF
   end