paradeiser 0.0.1 → 0.1.0

data/test/unit/test_pomodori_view.rb

@@ -0,0 +1,78 @@
+require 'helper'
+
+class TestPomodoriView < 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(/^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)
+    assert_empty(err)
+  end
+
+  def test_finish
+    start!
+    out, err = render(:finish)
+    assert_match(/^Finished pomodoro #1 after .* minutes\.$/m, out)
+  end
+
+private
+
+  def render(method)
+    capture_io do
+      View.new('Pomodori', method).render(binding)
+    end
+  end
+end

data/test/unit/test_pomodoro.rb

@@ -0,0 +1,100 @@
+require 'helper'
+
+class TestPomodoro < MiniTest::Test
+  def setup
+    @pom = Pomodoro.new
+  end
+
+  def test_virgin
+    assert_equal(:idle, @pom.status_name)
+  end
+
+  def test_finish_idle
+    assert_raises StateMachine::InvalidTransition do
+      finish!
+    end
+  end
+
+  def test_finish
+    start!
+    assert_equal(:active, @pom.status_name)
+
+    now = srand
+
+    Time.stub :now, Time.at(now) do
+      finish!
+    end
+
+    assert_equal(:finished, @pom.status_name)
+    assert_equal(now, @pom.finished_at.to_i)
+  end
+
+  def test_duration_idle
+    assert_equal(0, @pom.duration)
+  end
+
+  def test_duration_started
+    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, @pom.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, @pom.duration)
+  end
+
+  def test_finish_finished
+    start!
+    finish!
+    assert_raises StateMachine::InvalidTransition do
+      finish!
+    end
+  end
+
+  def test_start
+    now = srand
+
+    Time.stub :now, Time.at(now) do
+      start!
+    end
+
+    assert_equal(:active, @pom.status_name)
+    assert_equal(now, @pom.started_at.to_i)
+  end
+
+  def test_remaining
+    now = srand
+
+    Time.stub :now, Time.at(now) do
+      start!
+      assert_equal(Pomodoro::LENGTH_SECONDS, @pom.remaining)
+    end
+
+    delta = 600
+    later = now + delta
+
+    Time.stub :now, Time.at(later) do
+      assert_equal(Pomodoro::LENGTH_SECONDS - delta, @pom.remaining)
+    end
+  end
+end

data/test/unit/test_pomodoro_hooks.rb

@@ -0,0 +1,83 @@
+require 'helper'
+require 'tmpdir'
+
+class TestPomodoroHooks < MiniTest::Test
+  def setup
+    @orig_pom_dir = ENV['POM_DIR']
+    ENV['POM_DIR'] = Dir.mktmpdir
+  end
+
+  def teardown
+    FileUtils.rm_rf(Paradeiser.pom_dir)
+    ENV['POM_DIR'] = @orig_pom_dir
+  end
+
+  def test_before_finish_success
+    hook_name = 'before-finish'
+
+    pom = Pomodoro.new
+    pom.id = SecureRandom.random_number(1000)
+    pom.start
+    token_file = create_hook(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)
+  end
+
+  def test_before_finish_error
+    hook_name = 'before-finish'
+
+    pom = Pomodoro.new
+    pom.id = SecureRandom.random_number(1000)
+    pom.start
+    token_file = create_hook(hook_name, false)
+    refute_path_exists(token_file, "Token file must not exist before #{hook_name} hook is executed")
+
+    assert_raises HookFailedError do
+      pom.finish
+    end
+
+    refute_path_exists(token_file, "#{hook_name} hook should have created a token file")
+    assert_equal(:active, pom.status_name)
+  end
+
+private
+
+  def create_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)
+
+    File.open(hook_file, 'w') do |f|
+      if hook_succeeds
+        f.write(hook_contents_success(token_file))
+      else
+        f.write(hook_contents_failure)
+      end
+    end
+
+    File.chmod(0700, hook_file)
+
+    assert(File.exist?(hook_file))
+    token_file
+  end
+
+  def hook_contents_success(token_file)
+    hook_contents =<<"EOF"
+#!/bin/sh
+echo "Pomodoro $POM_ID started $POM_STARTED_AT" > #{token_file}
+EOF
+  end
+
+  def hook_contents_failure
+    hook_contents =<<"EOF"
+#!/bin/sh
+exit 1
+EOF
+  end
+end

data/test/unit/test_repository.rb

@@ -0,0 +1,127 @@
+require 'helper'
+
+class TestRepository < MiniTest::Test
+  def setup
+    @backend = PStoreMock.new
+  end
+
+  def test_save_idle
+    pom = Pomodoro.new
+
+    assert_raises IllegalStatusError do
+      invoke(:save, pom)
+    end
+
+    assert_equal(0, @backend.size)
+  end
+
+  def test_save_active
+    pom = Pomodoro.new
+    start!(pom)
+
+    invoke(:save, pom)
+
+    assert_equal(1, @backend.size)
+  end
+
+  def test_save_second_active
+    pom1 = Pomodoro.new
+    start!(pom1)
+
+    pom2 = Pomodoro.new
+    start!(pom2)
+
+    invoke(:save, pom1)
+
+    assert_raises SingletonError do
+      invoke(:save, pom2)
+    end
+
+    assert_equal(1, @backend.size)
+  end
+
+  def test_save_finished
+    pom = Pomodoro.new
+    start!(pom)
+    finish!(pom)
+
+    invoke(:save, pom)
+
+    assert_equal(1, @backend.size)
+  end
+
+  def test_save_active_finish_save
+    pom = Pomodoro.new
+    start!(pom)
+
+    invoke(:save, pom)
+    finish!(pom)
+    invoke(:save, pom)
+
+    assert_equal(1, @backend.size)
+  end
+
+  def test_all
+    @backend[:foo] = 'bar'
+    assert_equal(1, @backend.size)
+
+    all = invoke(:all)
+
+    assert_equal(1, all.size)
+  end
+
+  def test_any
+  end
+
+  def test_find
+    @backend[:foo] = PomodoroMock.new(:length => 3)
+    @backend[:bar] = PomodoroMock.new(:length => 3)
+    @backend[:baz] = PomodoroMock.new(:length => 2)
+    assert_equal(3, @backend.size)
+
+    all = invoke(:find){|pom| pom.length == 3}
+
+    assert_equal(2, all.size)
+  end
+
+  def test_active
+    @backend[:foo] = PomodoroMock.new(:active => false)
+    @backend[:bar] = PomodoroMock.new(:active => true)
+    @backend[:baz] = PomodoroMock.new(:active => false)
+
+    active = invoke(:active)
+    assert_equal(@backend[:bar], active)
+  end
+
+  def test_active_true
+    @backend[:foo] = PomodoroMock.new(:active => false)
+    @backend[:bar] = PomodoroMock.new(:active => true)
+    @backend[:baz] = PomodoroMock.new(:active => false)
+
+    assert(invoke(:active?))
+  end
+
+  def test_active_false
+    @backend[:foo] = PomodoroMock.new(:active => false)
+    @backend[:bar] = PomodoroMock.new(:active => false)
+    @backend[:baz] = PomodoroMock.new(:active => false)
+
+    refute(invoke(:active?))
+  end
+
+  def test_corrupted_repo
+    @backend[:foo] = PomodoroMock.new(:active => true)
+    @backend[:bar] = PomodoroMock.new(:active => true)
+
+    assert_raises SingletonError do
+      invoke(:active?)
+    end
+  end
+private
+
+  def invoke(method, *args, &blk)
+    Repository.stub :backend, @backend do
+      Repository.send(method, *args, &blk)
+    end
+  end
+end

data/test/unit/test_router.rb

@@ -0,0 +1,36 @@
+require 'helper'
+require 'fakefs/safe'
+
+class CommandMock < Struct.new(:name)
+end
+
+class TestRouter < MiniTest::Test
+  def setup
+    FakeFS.activate!
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  def test_init
+    refute(Dir.exists?(Paradeiser.pom_dir), "Expect #{Paradeiser.pom_dir} to not exist yet")
+
+    block = Router.new.dispatch(CommandMock.new(:init))
+    refute_nil(block)
+
+    refute(Dir.exists?(Paradeiser.pom_dir), "Expect #{Paradeiser.pom_dir} to not exist yet")
+
+    # fake the view
+    dirname = File.join(File.dirname(__FILE__), '..', '..', 'lib', 'paradeiser', 'views', 'paradeiser')
+    FileUtils.mkdir_p(dirname)
+    view = File.join(dirname, 'init.erb')
+    FileUtils.touch(view)
+
+    begin
+      block.call(nil, OptionsMock.new(:trace => true, :verbose => false))
+    ensure
+      FileUtils.rm_r(Paradeiser.pom_dir, :force => true)
+    end
+  end
+end

data/test/unit/test_scheduler.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+class TestScheduler < MiniTest::Test
+  def setup
+    if Scheduler.list.any?
+      @do_not_clear = true
+      raise "The at queue 't' is not empty. Clean it up before running this test again."
+    end
+  end
+
+  def teardown
+    Scheduler.clear unless @do_not_clear
+  end
+
+  def test_add
+    result = Scheduler.list
+    assert_equal(0, result.size)
+
+    job = Scheduler.add(:finish, 42)
+    refute_nil(job)
+    refute_nil(job.id)
+    assert(0 < job.id.to_i)
+
+    list = Scheduler.list
+    assert_equal(1, list.size)
+    assert_equal(job, list.first)
+  end
+
+  def test_clear
+    n = 3
+
+    n.times.each do |spec|
+      Scheduler.add(:finish, 43)
+    end
+
+    result = Scheduler.list
+    assert_equal(n, result.size)
+
+    Scheduler.clear
+
+    result = Scheduler.list
+    assert_equal(0, result.size)
+  end
+end