paradeiser 0.2.0 → 0.4.0

data/test/unit/test_paradeiser_controller_report.rb

@@ -1,44 +1,91 @@
 require 'helper'
 
-class TestParadeiserControllerReport < ControllerTest
+class TestParadeiserControllerReport < ParadeiserControllerTest
+  ATTR_NAMES = %w{has_output @finished @canceled @external_interrupts @internal_interrupts @breaks @break_minutes}
+
   def setup
     @backend = PStoreMock.new
   end
 
   def test_idle
-    br3ak, has_output = invoke(:report, '@pom', 'has_output')
-    assert_empty(br3ak)
-    assert_equal(true, has_output)
+    attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+    assert_equal(0, attrs[:finished])
+  end
+
+  def test_has_output
+    attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+    assert_equal(true, attrs[:has_output])
+  end
+
+  def test_finished
+    pom = produce(Pomodoro) # can't use mocks as long as the controller uses kind_of?
+    pom.started_at = Time.new(8)
+    pom.finished_at = Time.new(16)
+    pom.finish!
+    @backend[:bar] = pom
+
+    attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+    assert_equal(1, attrs[:finished])
   end
 
-  def test_active_break
-    @backend[:foo] = SchedulableMock.new(:status_name => :active)
+  def test_canceled
+    pom = produce(Pomodoro)
+    pom.started_at = Time.new(16)
+    pom.canceled_at = Time.new(24)
+    pom.cancel!
+    @backend[:bar] = pom
 
-    br3ak, has_output = invoke(:report, '@pom', 'has_output')
-    assert_equal(1, br3ak.size)
-    assert_equal(true, has_output)
+    attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+    assert_equal(1, attrs[:canceled])
   end
 
-  def test_finished_break
-    @backend[:foo] = SchedulableMock.new(:status_name => :finished)
-    @backend[:bar] = SchedulableMock.new(:status_name => :active)
-    br3ak, has_output = invoke(:report, '@pom', 'has_output')
-    assert_equal(2, br3ak.size)
-    assert_equal(true, has_output)
+  def test_external_interrupts
+    pom = produce(Pomodoro)
+    pom.started_at = Time.new(24)
+    pom.canceled_at = Time.new(32)
+    pom.interrupt!(:external)
+    @backend[:bar] = pom
+
+    attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+    assert_equal(1, attrs[:external_interrupts])
   end
 
-  def test_active_pom
-    @backend[:bar] = SchedulableMock.new(:status_name => :active)
-    pomodori, has_output = invoke(:report, '@pom', 'has_output')
-    assert_equal(1, pomodori.size)
-    assert_equal(true, has_output)
+  def test_internal_interrupts
+    pom = produce(Pomodoro)
+    pom.started_at = Time.new(32)
+    pom.canceled_at = Time.new(64)
+    pom.interrupt!(:internal)
+    @backend[:bar] = pom
+
+    attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+    assert_equal(1, attrs[:internal_interrupts])
   end
 
-  def test_finished_pom
-    @backend[:foo] = SchedulableMock.new(:status_name => :finished)
-    @backend[:bar] = SchedulableMock.new(:status_name => :active)
-    pomodori, has_output = invoke(:report, '@pom', 'has_output')
-    assert_equal(2, pomodori.size)
-    assert_equal(true, has_output)
+  def test_breaks
+    br3ak = produce(Break)
+    br3ak.started_at = Time.new(164)
+    br3ak.finished_at = Time.new(128)
+    @backend[:foo] = br3ak
+
+    attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+    assert_equal(1, attrs[:breaks])
+  end
+
+  def test_break_minutes
+    @backend[:foo] = make_break(5)
+    @backend[:bar] = make_break(3)
+    @backend[:baz] = make_break(2)
+
+    attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+    assert_equal(10, attrs[:break_minutes])
+  end
+
+private
+
+  def make_break(minutes = 5)
+    Break.new.tap do |b|
+      b.started_at = srand
+      b.finished_at = b.started_at + minutes * 60
+    end
   end
 end

data/test/unit/test_paradeiser_controller_status.rb

@@ -1,14 +1,16 @@
 require 'helper'
 
-class TestParadeiserControllerStatus < ControllerTest
+class TestParadeiserControllerStatus < ParadeiserControllerTest
   def setup
     @backend = PStoreMock.new
   end
 
   def test_status_idle
-    exitstatus, has_output = invoke(:status, 'exitstatus', 'has_output')
-    assert_equal(-1, exitstatus)
-    assert_equal(true, has_output)
+    attrs = invoke(:status, nil, nil, 'exitstatus', 'has_output')
+    assert_equal(-1, attrs[:exitstatus])
+    assert_equal(true, attrs[:has_output])
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
     assert_equal(0, @backend.size)
   end
 
@@ -17,12 +19,16 @@ class TestParadeiserControllerStatus < ControllerTest
       :status => 'active',
       :status_name => :active,
       :active => true,
-      :name => 'pomodoro')
+      :name => 'pomodoro',
+      :remaining => 0,
+      :started_at => Time.now)
 
-    pom, has_output, exitstatus = invoke(:status, '@pom', 'has_output', 'exitstatus')
-    assert_equal(0, exitstatus)
-    assert_equal(:active, pom.status_name)
-    assert_equal(true, has_output)
+    attrs = invoke(:status, nil, nil, '@pom', 'has_output', 'exitstatus')
+    assert_equal(0, attrs[:exitstatus])
+    assert_equal(:active, attrs[:pom].status_name)
+    assert_equal(true, attrs[:has_output])
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
     assert_equal(1, @backend.size)
   end
 
@@ -31,12 +37,16 @@ class TestParadeiserControllerStatus < ControllerTest
       :status => 'finished',
       :status_name => :finished,
       :finished => true,
-      :name => 'pomodoro')
+      :name => 'pomodoro',
+      :remaining => 0,
+      :finished_at => Time.now)
 
-    pom, has_output, exitstatus = invoke(:status, '@pom', 'has_output', 'exitstatus')
-    assert_equal(1, exitstatus)
-    assert_equal(:finished, pom.status_name)
-    assert_equal(true, has_output)
+    attrs = invoke(:status, nil, nil, '@pom', 'has_output', 'exitstatus')
+    assert_equal(1, attrs[:exitstatus])
+    assert_equal(:finished, attrs[:pom].status_name)
+    assert_equal(true, attrs[:has_output])
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
     assert_equal(1, @backend.size)
   end
 
@@ -45,12 +55,16 @@ class TestParadeiserControllerStatus < ControllerTest
       :status => 'active',
       :status_name => :active,
       :active => true,
-      :name => 'break')
+      :name => 'break',
+      :remaining => 0,
+      :started_at => Time.now)
 
-    pom, has_output, exitstatus = invoke(:status, '@pom', 'has_output', 'exitstatus')
-    assert_equal(2, exitstatus)
-    assert_equal(:active, pom.status_name)
-    assert_equal(true, has_output)
+    attrs = invoke(:status, nil, nil, '@pom', 'has_output', 'exitstatus')
+    assert_equal(2, attrs[:exitstatus])
+    assert_equal(:active, attrs[:pom].status_name)
+    assert_equal(true, attrs[:has_output])
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
     assert_equal(1, @backend.size)
   end
 
@@ -59,12 +73,16 @@ class TestParadeiserControllerStatus < ControllerTest
       :status => 'finished',
       :status_name => :finished,
       :finished => true,
-      :name => 'break')
+      :name => 'break',
+      :remaining => 0,
+      :finished_at => Time.now)
 
-    pom, has_output, exitstatus = invoke(:status, '@pom', 'has_output', 'exitstatus')
-    assert_equal(3, exitstatus)
-    assert_equal(:finished, pom.status_name)
-    assert_equal(true, has_output)
+    attrs = invoke(:status, nil, nil, '@pom', 'has_output', 'exitstatus')
+    assert_equal(3, attrs[:exitstatus])
+    assert_equal(:finished, attrs[:pom].status_name)
+    assert_equal(true, attrs[:has_output])
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
     assert_equal(1, @backend.size)
   end
 end

data/test/unit/test_paradeiser_view_init.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestParadeiserViewInit < ParadeiserViewTest
+  def test_init
+    assert_match(/^Successfully initialized .+\.$/, render(:init))
+  end
+end

data/test/unit/test_paradeiser_view_report.rb

@@ -0,0 +1,132 @@
+require 'helper'
+
+class TestParadeiserViewReport < ParadeiserViewTest
+
+  def setup
+    @annotations = []
+  end
+
+  def test_report_0
+    out = render(:report)
+    assert(out)
+    lines = out.lines
+    assert_equal(6, lines.size)
+
+    i = 0
+    assert_equal('# Pomodoro Report', lines[i].chomp)
+
+    i += 1
+    assert_match(/^- \d pomodori finished$/, lines[i].chomp)
+    assert_equal('0', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d pomodori canceled$/, lines[i].chomp)
+    assert_equal('0', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d internal interrupts$/, lines[i].chomp)
+    assert_equal('0', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d external interrupts$/, lines[i].chomp)
+    assert_equal('0', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d breaks \(\d minutes in total\)$/, lines[i].chomp)
+    assert_equal('0', lines[i][2])
+    assert_equal('0', lines[i][12])
+  end
+
+  def test_report_1
+    @finished = 1
+    @canceled = 1
+    @external_interrupts = 1
+    @internal_interrupts = 1
+    @breaks = 1
+    @break_minutes = 1
+
+    out = render(:report)
+    assert(out)
+    lines = out.lines
+    assert_equal(6, lines.size)
+
+    i = 0
+    assert_equal('# Pomodoro Report', lines[i].chomp)
+
+    i += 1
+    assert_match(/^- \d pomodoro finished$/, lines[i].chomp)
+    assert_equal('1', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d pomodoro canceled$/, lines[i].chomp)
+    assert_equal('1', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d internal interrupt$/, lines[i].chomp)
+    assert_equal('1', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d external interrupt$/, lines[i].chomp)
+    assert_equal('1', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d break \(\d minute in total\)$/, lines[i].chomp)
+    assert_equal('1', lines[i][2])
+    assert_equal('1', lines[i][11])
+  end
+
+  def test_report_2
+    @finished = 2
+    @canceled = 2
+    @external_interrupts = 2
+    @internal_interrupts = 2
+    @breaks = 2
+    @break_minutes = 2
+
+    out = render(:report)
+    assert(out)
+    lines = out.lines
+    assert_equal(6, lines.size)
+
+    i = 0
+    assert_equal('# Pomodoro Report', lines[i].chomp)
+
+    i += 1
+    assert_match(/^- \d pomodori finished$/, lines[i].chomp)
+    assert_equal('2', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d pomodori canceled$/, lines[i].chomp)
+    assert_equal('2', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d internal interrupts$/, lines[i].chomp)
+    assert_equal('2', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d external interrupts$/, lines[i].chomp)
+    assert_equal('2', lines[i][2])
+
+    i += 1
+    assert_match(/^- \d breaks \(\d minutes in total\)$/, lines[i].chomp)
+    assert_equal('2', lines[i][2])
+    assert_equal('2', lines[i][12])
+  end
+
+  def test_report_annotations
+    @annotations = ['seven eleven', 'fourty two', 'something real']
+
+    out = render(:report)
+    assert(out)
+    lines = out.lines
+    assert_equal(11, lines.size)
+
+    i = 7
+    assert_equal('## Annotations', lines[i].chomp)
+
+    i += 1
+    @annotations.each_with_index do |annotation, ai|
+      assert_equal("* #{annotation}", lines[i + ai].chomp)
+    end
+  end
+end

data/test/unit/test_paradeiser_view_status.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class TestParadeiserViewStatus < ParadeiserViewTest
+  def setup
+    @pom = produce(Pomodoro)
+    @pom.id = 1
+  end
+
+  def test_active
+    assert_match(/^Pomodoro #1 is active for another .* minutes \(started at .*\)\.$/m, render(:status))
+  end
+
+  def test_finished
+    finish!
+    assert_match(/^Nothing active. Last pomodoro was finished at .*\.$/m, render(:status))
+  end
+end

data/test/unit/test_pomodori_controller.rb

@@ -1,14 +1,29 @@
 require 'helper'
 
-class TestPomodoriController < MiniTest::Test
+class TestPomodoriController < ControllerTest
   def setup
     @backend = PStoreMock.new
   end
 
+  def model
+    'pomodoro'
+  end
+
   def test_start
-    pom, has_output = invoke(:start, nil, '@pom', 'has_output')
-    assert_equal(:active, pom.status_name)
-    assert_equal(false, has_output)
+    attrs = invoke(:start, nil, nil, '@pom', 'has_output')
+    assert_equal(:active, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+  end
+
+  def test_start_verbose
+    attrs = invoke(:start, nil, OpenStruct.new(:verbose => true), '@pom', 'has_output')
+    assert_equal(:active, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
     assert_equal(1, @backend.size)
   end
 
@@ -24,9 +39,21 @@ class TestPomodoriController < MiniTest::Test
 
   def test_finish
     invoke(:start)
-    pom, has_output = invoke(:finish, nil, '@pom', 'has_output')
-    assert_equal(:finished, pom.status_name)
-    assert_equal(false, has_output)
+    attrs = invoke(:finish, nil, nil, '@pom', 'has_output')
+    assert_equal(:finished, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+  end
+
+  def test_finish_verbose
+    invoke(:start)
+    attrs = invoke(:finish, nil, OpenStruct.new(:verbose => true), '@pom', 'has_output')
+    assert_equal(:finished, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
     assert_equal(1, @backend.size)
   end
 
@@ -58,10 +85,12 @@ class TestPomodoriController < MiniTest::Test
 
   def test_interrupt_active
     invoke(:start)
-    pom, has_output = invoke(:interrupt, OpenStruct.new, '@pom', 'has_output')
-    assert_equal(:active, pom.status_name)
+    attrs = invoke(:interrupt, nil, OpenStruct.new, '@pom', 'has_output')
+    assert_equal(:active, attrs[:pom].status_name)
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
 
-    interrupts = pom.interrupts
+    interrupts = attrs[:pom].interrupts
     refute_nil(interrupts)
     refute_empty(interrupts)
     assert_equal(1, interrupts.size)
@@ -72,17 +101,25 @@ class TestPomodoriController < MiniTest::Test
     assert_equal(:internal, interrupt.type)
   end
 
+  def test_interrupt_active_verbose
+    invoke(:start)
+    attrs = invoke(:interrupt, nil, OpenStruct.new(:verbose => true), '@pom', 'has_output')
+    assert_equal(:active, attrs[:pom].status_name)
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+  end
+
   def test_interrupt_active_internal
     invoke(:start)
-    pom = invoke(:interrupt, OpenStruct.new(:internal => true), '@pom')
-    interrupt = pom.interrupts.first
+    attrs = invoke(:interrupt, nil, OpenStruct.new(:internal => true), '@pom')
+    interrupt = attrs[:pom].interrupts.first
     assert_equal(:internal, interrupt.type)
   end
 
   def test_interrupt_active_external
     invoke(:start)
-    pom = invoke(:interrupt, OpenStruct.new(:external => true), '@pom')
-    interrupt = pom.interrupts.first
+    attrs = invoke(:interrupt, nil, OpenStruct.new(:external => true), '@pom')
+    interrupt = attrs[:pom].interrupts.first
     assert_equal(:external, interrupt.type)
   end
 
@@ -107,9 +144,21 @@ class TestPomodoriController < MiniTest::Test
 
   def test_cancel_active
     invoke(:start)
-    pom, has_output = invoke(:cancel, nil, '@pom', 'has_output')
-    assert_equal(:canceled, pom.status_name)
-    assert_equal(false, has_output)
+    attrs = invoke(:cancel, nil, nil, '@pom', 'has_output')
+    assert_equal(:canceled, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+  end
+
+  def test_cancel_active_verbose
+    invoke(:start)
+    attrs = invoke(:cancel, nil, OpenStruct.new(:verbose => true), '@pom', 'has_output')
+    assert_equal(:canceled, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
     assert_equal(1, @backend.size)
   end
 
@@ -133,27 +182,186 @@ class TestPomodoriController < MiniTest::Test
     assert_equal(2, @backend.size)
   end
 
-private
+  def test_log_active
+    invoke(:start)
+    annotation_args = name.split('_')
+    attrs = invoke(:log, annotation_args, nil, '@pom', 'has_output')
+    pom = attrs[:pom]
+    assert_kind_of(Pomodoro, pom)
+    assert_equal(:finished, pom.status_name)
+  end
 
-  def invoke(method, options = nil, *attributes)
-    controller = PomodoriController.new(method)
+  def test_log_inactive
+    annotation_args = name.split('_')
+    now = srand
 
-    Repository.stub :backend, @backend do
-      Scheduler.stub(:add, nil) do
-        Scheduler.stub(:clear, nil) do
-          controller.call(nil, options)
-        end
-      end
+    attrs = Time.stub :now, Time.at(now) do
+      invoke(:log, annotation_args, nil, '@pom', 'has_output')
     end
 
-    result = attributes.map do |attribute|
-      controller.get_binding.eval(attribute)
-    end
+    assert(attrs)
+    pom = attrs[:pom]
+    assert(pom)
+    assert_kind_of(Pomodoro, pom)
+    assert_equal(:finished, pom.status_name)
+    assert_equal(Time.at(now - Pomodoro::MINUTES_25 * 60), pom.started_at)
+    assert_equal(Time.at(now), pom.finished_at)
+
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+
+    annotations = attrs[:pom].annotations
+    assert(annotations)
+    assert_equal(1, annotations.size)
+    assert_equal(annotation_args.join(' '), annotations.first)
+  end
+
+  def test_log_active_verbose
+    invoke(:start)
+    attrs = invoke(:log, nil, OpenStruct.new(:verbose => true), '@pom', 'has_output')
+    assert_equal(:finished, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(2, @backend.size)
+  end
+
+  def test_log_inactive_verbose
+    attrs = invoke(:log, nil, OpenStruct.new(:verbose => true), '@pom', 'has_output')
+    assert_equal(:finished, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+  end
+
+  def test_annotate_active
+    invoke(:start)
+    annotation_args = 'foobar w00t'.split
+    attrs = invoke(:annotate, annotation_args, nil, '@pom', 'has_output')
+    assert_equal(:active, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+    annotations = attrs[:pom].annotations
+    assert(annotations)
+    assert_equal(1, annotations.size)
+    assert_equal(annotation_args.join(' '), annotations.first)
+  end
+
+  def test_annotate_active_verbose
+    invoke(:start)
+    attrs = invoke(:annotate, ['annotation', 'args'], OpenStruct.new(:verbose => true), '@pom', 'has_output')
+    refute_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+  end
+
+  def test_annotate_second_last_successful
+    invoke(:start)
+    invoke(:finish)
+
+    @backend[:foo] = SchedulableMock.new(
+      :status => 'finished',
+      :status_name => :finished,
+      :finished => true,
+      :name => 'break',
+      :remaining => 0,
+      :finished_at => Time.now)
 
-    if 1 == result.size
-      result.first
-    else
-      result
+    last = Repository.stub :backend, @backend do
+      Repository.all.last
     end
+    assert_kind_of(SchedulableMock, last)
+
+    annotation_args = name.split('_')
+    attrs = invoke(:annotate, annotation_args, nil, '@pom', 'has_output')
+
+    pom = attrs[:pom]
+    assert_kind_of(Pomodoro, pom)
+    assert_equal(:finished, pom.status_name)
+
+    annotations = pom.annotations
+    assert(annotations)
+    assert_equal(1, annotations.size)
+    assert_equal(annotation_args.join(' '), annotations.first)
+  end
+
+  def test_annotate_last_successful
+    invoke(:start)
+    invoke(:finish)
+    annotation_args = name.split('_')
+    attrs = invoke(:annotate, annotation_args, nil, '@pom', 'has_output')
+    assert_equal(:finished, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+    annotations = attrs[:pom].annotations
+    assert(annotations)
+    assert_equal(1, annotations.size)
+    assert_equal(annotation_args.join(' '), annotations.first)
+  end
+
+  def test_annotate_last_canceled
+    invoke(:start)
+    invoke(:cancel)
+    annotation_args = name.split('_')
+    attrs = invoke(:annotate, annotation_args, nil, '@pom', 'has_output')
+    assert_equal(:canceled, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+    annotations = attrs[:pom].annotations
+    assert(annotations)
+    assert_equal(1, annotations.size)
+    assert_equal(annotation_args.join(' '), annotations.first)
+  end
+
+  def test_annotate_finish
+    invoke(:start)
+    annotation_args = name.split('_')
+    attrs = invoke(:finish, annotation_args, nil, '@pom', 'has_output')
+    assert_equal(:finished, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+    annotations = attrs[:pom].annotations
+    assert(annotations)
+    assert_equal(1, annotations.size)
+    assert_equal(annotation_args.join(' '), annotations.first)
+  end
+
+  def test_annotate_interrupt
+    invoke(:start)
+    annotation_args = name.split('_')
+    attrs = invoke(:interrupt, annotation_args, OpenStruct.new, '@pom', 'has_output')
+    assert_equal(:active, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+    annotations = attrs[:pom].annotations
+    assert(annotations)
+    assert_equal(1, annotations.size)
+    assert_equal(annotation_args.join(' '), annotations.first)
+  end
+
+  def test_annotate_cancel
+    invoke(:start)
+    annotation_args = name.split('_')
+    attrs = invoke(:cancel, annotation_args, nil, '@pom', 'has_output')
+    assert_equal(:canceled, attrs[:pom].status_name)
+    assert_equal(false, attrs[:has_output])
+    assert_empty(attrs[:stdout])
+    assert_empty(attrs[:stderr])
+    assert_equal(1, @backend.size)
+    annotations = attrs[:pom].annotations
+    assert(annotations)
+    assert_equal(1, annotations.size)
+    assert_equal(annotation_args.join(' '), annotations.first)
   end
 end