paradeiser 0.1.0 → 0.2.0

data/test/integration/{test_pom.rb → test_par.rb}

@@ -1,16 +1,16 @@
 require 'helper'
 
-class TestPom < MiniTest::Test
-  POM_BIN = 'pom'
+class TestPar < MiniTest::Test
+  PAR = 'bin/par'
 
   def test_no_args_defaults_to_help
-    out, err, status = Open3.capture3(POM_BIN)
+    out, err, status = Open3.capture3(PAR)
     assert_equal(0, status.exitstatus, "Expected exit status to be 0, but it was #{status.exitstatus}. STDERR contains: #{err}")
     assert_empty(err)
   end
 
   def test_unknown
-    out, err, status = Open3.capture3("#{POM_BIN} unknown")
+    out, err, status = Open3.capture3("#{PAR} unknown")
     refute_equal(0, status.exitstatus)
     refute_empty(err)
   end

data/test/lib/{pomodoro_mock.rb → schedulable_mock.rb}

@@ -1,6 +1,6 @@
 require 'ostruct'
 
-class PomodoroMock < OpenStruct
+class SchedulableMock < OpenStruct
   def initialize(attributes)
     super(attributes)
   end
@@ -8,4 +8,12 @@ class PomodoroMock < OpenStruct
   def active?
     !!active
   end
+
+  def finished?
+    !!finished
+  end
+
+  def canceled?
+    !!canceled
+  end
 end

data/test/unit/test_break.rb

@@ -0,0 +1,99 @@
+require 'helper'
+
+class TestBreak < MiniTest::Test
+  def setup
+    @break = Break.new
+  end
+
+  def test_virgin
+    assert_equal(:idle, @break.status_name)
+  end
+
+  def test_break
+    start!
+    assert_equal(:active, @break.status_name)
+  end
+
+  def test_finish_idle
+    assert_raises StateMachine::InvalidTransition do
+      finish!
+    end
+  end
+
+  def test_finish_break
+    start!
+    assert_equal(:active, @break.status_name)
+
+    now = srand
+
+    Time.stub :now, Time.at(now) do
+      finish!
+    end
+
+    assert_equal(:finished, @break.status_name)
+    assert_equal(now, @break.finished_at.to_i)
+  end
+
+  def test_length
+    assert_equal(5 * 60, @break.length)
+  end
+
+
+  def test_duration_idle
+    assert_equal(0, @break.duration)
+  end
+
+  def test_duration
+    now = srand
+
+    Time.stub :now, Time.at(now) do
+      start!
+    end
+
+    later = now + rand(42)
+
+    Time.stub :now, Time.at(later) do
+      assert_equal(later - now, @break.duration)
+    end
+  end
+
+  def test_duration_finished
+    now = srand
+
+    Time.stub :now, Time.at(now) do
+      start!
+    end
+
+    later = now + rand(42)
+
+    Time.stub :now, Time.at(later) do
+      finish!
+    end
+
+    assert_equal(later - now, @break.duration)
+  end
+
+  def test_finish_break
+    start!
+    finish!
+    assert_raises StateMachine::InvalidTransition do
+      finish!
+    end
+  end
+
+  def test_remaining
+    now = srand
+
+    Time.stub :now, Time.at(now) do
+      start!
+      assert_equal(@break.length, @break.remaining)
+    end
+
+    delta = 120
+    later = now + delta
+
+    Time.stub :now, Time.at(later) do
+      assert_equal(@break.length - delta, @break.remaining)
+    end
+  end
+end

data/test/unit/test_break_controller.rb

@@ -0,0 +1,56 @@
+require 'helper'
+
+class TestBreakController < MiniTest::Test
+  def setup
+    @backend = PStoreMock.new
+  end
+
+  def test_break
+    br3k, has_output = invoke(:start, '@break', 'has_output')
+    assert_equal(:active, br3k.status_name)
+    assert_equal(false, has_output)
+    assert_equal(1, @backend.size)
+  end
+
+  def test_break_active
+    invoke(:start)
+    assert_equal(1, @backend.size)
+
+    assert_raises SingletonError do
+      invoke(:start)
+    end
+    assert_equal(1, @backend.size)
+  end
+
+  def test_finish
+    invoke(:start)
+    br3ak, has_output = invoke(:finish, '@break', 'has_output')
+    assert_equal(:finished, br3ak.status_name)
+    assert_equal(false, has_output)
+    assert_equal(1, @backend.size)
+  end
+
+  def test_finish_idle
+    assert_raises NotActiveError do
+      invoke(:finish)
+    end
+    assert_equal(0, @backend.size)
+  end
+private
+
+  def invoke(method, *attributes)
+    controller = BreaksController.new(method)
+
+    Repository.stub :backend, @backend do
+      Scheduler.stub(:add, nil) do
+        Scheduler.stub(:clear, nil) do
+          controller.call(nil, nil)
+        end
+      end
+    end
+
+    attributes.map do |attribute|
+      controller.get_binding.eval(attribute)
+    end
+  end
+end

data/test/unit/test_interrupt.rb

@@ -0,0 +1,36 @@
+require 'helper'
+
+class TestInterrupt < MiniTest::Test
+  def setup
+    @now = srand
+  end
+
+  def test_created_at
+    int = new_interrupt
+    assert_equal(@now, int.created_at.to_i)
+  end
+
+  def test_defaults_to_internal
+    int = new_interrupt
+    assert_equal(:internal, int.type)
+  end
+
+  def test_external
+    int = new_interrupt(:external)
+    assert_equal(:external, int.type)
+  end
+
+  def test_unknown
+    assert_raises InvalidTypeError do
+      new_interrupt(:unknown)
+    end
+  end
+
+private
+
+  def new_interrupt(type = nil)
+    Time.stub :now, Time.at(@now) do
+      Paradeiser::Interrupt.new(type)
+    end
+  end
+end

data/test/unit/test_paradeiser_controller_init.rb

@@ -0,0 +1,92 @@
+require 'helper'
+require 'fakefs/safe'
+
+class TestParadeiserControllerInit < MiniTest::Test
+  HOOKS = ['after-finish', 'before-finish']
+
+  def setup
+    @orig_PAR_DIR = ENV['PAR_DIR']
+    FakeFS.activate!
+    create_hook_templates
+  end
+
+  def teardown
+    FileUtils.rm_r(Paradeiser.par_dir, :force => true) if Dir.exists?(Paradeiser.par_dir)
+    FakeFS.deactivate!
+    ENV['PAR_DIR'] = @orig_PAR_DIR
+  end
+
+  def test_init_virgin
+    ENV.delete('PAR_DIR')
+    refute(Dir.exists?(Paradeiser.par_dir), "Expect #{Paradeiser.par_dir} to not exist yet")
+
+    invoke(:init)
+    assert(Dir.exists?(Paradeiser.par_dir))
+    assert_hooks_exist
+  end
+
+  def test_init_existing
+    FileUtils.mkdir_p(Paradeiser.par_dir, 0700)
+    assert(Dir.exists?(Paradeiser.par_dir))
+
+    invoke(:init)
+    assert(Dir.exists?(Paradeiser.par_dir))
+    assert_hooks_exist
+  end
+
+  def test_init_virgin_with_env_override
+    dir = tempdir_name
+    refute_equal(dir, Paradeiser.par_dir)
+    ENV['PAR_DIR'] = dir
+    assert_equal(dir, Paradeiser.par_dir)
+    refute(Dir.exists?(Paradeiser.par_dir), "PAR_DIR override #{Paradeiser.par_dir} must not exist")
+
+    invoke(:init)
+
+    assert(Dir.exists?(Paradeiser.par_dir))
+    assert_hooks_exist
+  end
+
+  def test_init_existing_with_env_override
+    ENV.delete('PAR_DIR')
+
+    Dir.mktmpdir do |dir|
+      refute_equal(dir, Paradeiser.par_dir)
+      ENV['PAR_DIR'] = dir
+      assert_equal(dir, Paradeiser.par_dir)
+      assert(Dir.exists?(Paradeiser.par_dir), "PAR_DIR override #{Paradeiser.par_dir} must exist")
+
+      invoke(:init)
+      assert(Dir.exists?(Paradeiser.par_dir), "PAR_DIR override #{Paradeiser.par_dir} must exist")
+      assert_hooks_exist
+    end
+  end
+
+private
+
+  def invoke(verb)
+    ParadeiserController.new(verb).call(nil, nil)
+  end
+
+  # Makes a temporary directory name, but does not create the directory
+  def tempdir_name
+    dir = File.join(Dir.tmpdir, SecureRandom.uuid)
+    refute(Dir.exists?(dir))
+    dir
+  end
+
+  def create_hook_templates
+    hook_templates_dir = File.join(Paradeiser.templates_dir, Paradeiser.os.to_s, 'hooks')
+    FileUtils.mkdir_p(hook_templates_dir)
+
+    HOOKS.each do |hook|
+      FileUtils.touch(File.join(hook_templates_dir, hook))
+    end
+  end
+
+  def assert_hooks_exist
+    HOOKS.each do |hook|
+      assert(File.exist?(File.join(Paradeiser.hooks_dir, hook)))
+    end
+  end
+end

data/test/unit/test_paradeiser_controller_report.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+class TestParadeiserControllerReport < ControllerTest
+  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)
+  end
+
+  def test_active_break
+    @backend[:foo] = SchedulableMock.new(:status_name => :active)
+
+    br3ak, has_output = invoke(:report, '@pom', 'has_output')
+    assert_equal(1, br3ak.size)
+    assert_equal(true, has_output)
+  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)
+  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)
+  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)
+  end
+end

data/test/unit/test_paradeiser_controller_status.rb

@@ -0,0 +1,70 @@
+require 'helper'
+
+class TestParadeiserControllerStatus < ControllerTest
+  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)
+    assert_equal(0, @backend.size)
+  end
+
+  def test_status_active_pom
+    @backend[:foo] = SchedulableMock.new(
+      :status => 'active',
+      :status_name => :active,
+      :active => true,
+      :name => 'pomodoro')
+
+    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)
+    assert_equal(1, @backend.size)
+  end
+
+  def test_status_finished_pom
+    @backend[:foo] = SchedulableMock.new(
+      :status => 'finished',
+      :status_name => :finished,
+      :finished => true,
+      :name => 'pomodoro')
+
+    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)
+    assert_equal(1, @backend.size)
+  end
+
+  def test_status_active_break
+    @backend[:foo] = SchedulableMock.new(
+      :status => 'active',
+      :status_name => :active,
+      :active => true,
+      :name => 'break')
+
+    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)
+    assert_equal(1, @backend.size)
+  end
+
+  def test_status_finished_break
+    @backend[:foo] = SchedulableMock.new(
+      :status => 'finished',
+      :status_name => :finished,
+      :finished => true,
+      :name => 'break')
+
+    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)
+    assert_equal(1, @backend.size)
+  end
+end

data/test/unit/test_paradeiser_view.rb

@@ -0,0 +1,66 @@
+require 'helper'
+
+class TestParadeiserView < MiniTest::Test
+  def setup
+    @pom = Pomodoro.new
+    @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(/^Nothing active. Last pomodoro 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 \| Name \| Status \| Started \| Ended | Interrupts$/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 \| Name \| Status \| Started \| Ended | Interrupts$/m, out.lines[0])
+    assert_match(/^1 \| pomodoro \| active \| \d{1,2}:\d{1,2} \|  \| \d+ I, \d+ E$/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 \| Name \| Status \| Started \| Ended | Interrupts$/m, out.lines[0])
+    assert_match(/^1 \| pomodoro \| finished \| \d{1,2}:\d{1,2} \| \d{1,2}:\d{1,2} \| \d+ I, \d+ E$/m, out.lines[1])
+    assert_empty(err)
+  end
+
+private
+
+  def render(method)
+    capture_io do
+      View.new('Paradeiser', method).render(binding)
+    end
+  end
+end