paradeiser 0.4.0 → 0.5.0

data/test/integration/test_start.rb

@@ -1,7 +1,9 @@
 require 'helper'
 
-class TestStartCommand < Paradeiser::IntegrationTest
-  def test_start
-    assert_command('start')
+module ParadeiserTest
+  class TestStartCommand < IntegrationTest
+    def test_start
+      assert_command('start')
+    end
   end
 end

data/test/integration/test_status.rb

@@ -1,10 +1,12 @@
 require 'helper'
 
-class TestStatusCommand < Paradeiser::IntegrationTest
-  def test_status
-    assert_command('status', 255) # not initialized
-    assert_command('start')
-    out = assert_command('status')
-    refute_empty(out, "Expected 'status' to produce an non-empty output")
+module ParadeiserTest
+  class TestStatusCommand < IntegrationTest
+    def test_status
+      assert_command('status', 255) # not initialized
+      assert_command('start')
+      out = assert_command('status')
+      refute_empty(out, "Expected 'status' to produce an non-empty output")
+    end
   end
 end

data/test/integration/test_unknown.rb

@@ -1,7 +1,9 @@
 require 'helper'
 
-class TestUnknownCommand < Paradeiser::IntegrationTest
-  def test_unknown
-    refute_command('unknown')
+module ParadeiserTest
+  class TestUnknownCommand < IntegrationTest
+    def test_unknown
+      refute_command('unknown')
+    end
   end
 end

data/test/lib/controller_test.rb

@@ -1,5 +1,7 @@
-module Paradeiser
-  class ControllerTest < MiniTest::Test
+require 'helper'
+
+module ParadeiserTest
+  class ControllerTest < UnitTest
     def invoke(method, args = nil, options = nil, *attributes)
       controller = Paradeiser.const_get("#{model.pluralize.capitalize}Controller".to_sym).new(method)
 

data/test/lib/integration_test.rb

@@ -1,6 +1,7 @@
 require 'helper'
+require 'shellwords'
 
-module Paradeiser
+module ParadeiserTest
   #
   # We put all integration tests into separate files so we only run one at a
   # time after a change. These tests are expensive to run.
@@ -9,6 +10,11 @@ module Paradeiser
     PAR = 'bin/par'
     include Executor
 
+    def initialize(*args)
+      super(*args)
+      @do_not_clear = nil
+    end
+
     def setup
       if Scheduler.list.any?
         @do_not_clear = true
@@ -16,7 +22,7 @@ module Paradeiser
       end
 
       @orig_PAR_DIR = ENV['PAR_DIR']
-      ENV['PAR_DIR'] = Dir.mktmpdir
+      ENV['PAR_DIR'] = Dir.mktmpdir(name)
       ENV['PAR_AT_QUEUE'] = 'i'
       assert_command('init')
     end

data/test/lib/paradeiser_controller_test.rb

@@ -1,4 +1,10 @@
-module Paradeiser
+require 'helper'
+
+module ParadeiserTest
+  # Not sure why Gurd seems to require this here ...
+  class ControllerTest < UnitTest
+  end
+
   class ParadeiserControllerTest < ControllerTest
     def model
       'paradeiser'

data/test/lib/token_file_registry.rb

@@ -0,0 +1,19 @@
+require 'tmpdir'
+
+module ParadeiserTest
+  class TokenFileRegistry
+    def initialize
+      @token_files = []
+    end
+
+    def create
+      token_file = File.join(Dir.tmpdir, SecureRandom.uuid)
+      @token_files << token_file
+      token_file
+    end
+
+    def cleanup
+      @token_files.each{|tf| FileUtils.rm(tf) if File.exist?(tf)}
+    end
+  end
+end

data/test/lib/unit_test.rb

@@ -0,0 +1,47 @@
+require 'minitest/autorun'
+
+module ParadeiserTest
+  class UnitTest < 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(name)
+    end
+
+    def teardown
+      FileUtils.rm_rf(ENV['PAR_DIR'])
+      ENV['PAR_DIR'] = @orig_PAR_DIR
+    end
+
+    protected
+
+    def produce(clazz)
+      @started = srand
+
+      Time.stub :now, Time.at(@started) do
+        Scheduler.stub(:add, nil) do
+          clazz.new
+        end
+      end
+    end
+
+    def interrupt!(type = :internal, pom = @pom)
+      Scheduler.stub(:clear, nil) do
+        pom.interrupt!(type)
+      end
+    end
+
+    def finish!(thing = @pom || @break)
+      Scheduler.stub(:clear, nil) do
+        thing.finish!
+      end
+    end
+
+    def cancel!(pom = @pom)
+      Scheduler.stub(:clear, nil) do
+        pom.cancel!
+      end
+    end
+  end
+end

data/test/lib/view_test.rb

@@ -1,12 +1,17 @@
-class ViewTest < MiniTest::Test
-  def render(method)
-    View.new(model.pluralize, method).render(binding)
+require 'helper'
+
+module ParadeiserTest
+  class ViewTest < UnitTest
+    def render(method)
+      View.new(model.pluralize, method).render(binding)
+    end
   end
-end
 
-class ParadeiserViewTest < ViewTest
-protected
-  def model
-    'Paradeiser'
+  class ParadeiserViewTest < ViewTest
+    protected
+
+    def model
+      'Paradeiser'
+    end
   end
 end

data/test/scripts/create-failing-hooks

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+hooks=(
+  "after-finish-break"
+  "after-finish-pomodoro"
+  "after-start-break"
+  "after-start-pomodoro"
+  "before-finish-break"
+  "before-finish-pomodoro"
+  "before-start-break"
+  "before-start-pomodoro")
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+for hook in ${hooks[*]}; do
+  ln -s "$DIR/fail" "$HOME/.paradeiser/hooks/$hook"
+done

data/test/scripts/fail

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+echo Tests must not execute the "$(basename "${BASH_SOURCE[0]}")" hook from "$DIR". >&2
+false

data/test/unit/test_break.rb

@@ -1,62 +1,65 @@
 require 'helper'
 
-class TestBreak < MiniTest::Test
-  def setup
-    @break = produce(Break)
-  end
+module ParadeiserTest
+  class TestBreak < UnitTest
+    def setup
+      super
+      @break = produce(Break)
+    end
 
-  def test_new
-    assert_equal(:active, @break.status_name)
-  end
+    def test_new
+      assert_equal(:active, @break.status_name)
+    end
 
-  def test_finish_break
-    assert_equal(:active, @break.status_name)
+    def test_finish_break
+      assert_equal(:active, @break.status_name)
 
-    now = srand
+      now = srand
 
-    Time.stub :now, Time.at(now) do
-      finish!
-    end
+      Time.stub :now, Time.at(now) do
+        finish!
+      end
 
-    assert_equal(:finished, @break.status_name)
-    assert_equal(now, @break.finished_at.to_i)
-  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_length
+      assert_equal(5 * 60, @break.length)
+    end
 
-  def test_duration
-    later = @started + rand(42)
+    def test_duration
+      later = @started + rand(42)
 
-    Time.stub :now, Time.at(later) do
-      assert_equal(later - @started, @break.duration)
+      Time.stub :now, Time.at(later) do
+        assert_equal(later - @started, @break.duration)
+      end
     end
-  end
 
-  def test_duration_finished
-    later = @started + rand(42)
+    def test_duration_finished
+      later = @started + rand(42)
 
-    Time.stub :now, Time.at(later) do
-      finish!
-    end
+      Time.stub :now, Time.at(later) do
+        finish!
+      end
 
-    assert_equal(later - @started, @break.duration)
-  end
+      assert_equal(later - @started, @break.duration)
+    end
 
-  def test_finish_break
-    finish!
-    assert_raises StateMachine::InvalidTransition do
+    def test_finish_break
       finish!
+      assert_raises StateMachine::InvalidTransition do
+        finish!
+      end
     end
-  end
 
-  def test_remaining
-    delta = 120
-    later = @started + delta
+    def test_remaining
+      delta = 120
+      later = @started + delta
 
-    Time.stub :now, Time.at(later) do
-      assert_equal(@break.length - delta, @break.remaining)
+      Time.stub :now, Time.at(later) do
+        assert_equal(@break.length - delta, @break.remaining)
+      end
     end
   end
 end

data/test/unit/test_break_view.rb

@@ -1,22 +1,25 @@
 require 'helper'
 
-class TestBreakView < ViewTest
-  def setup
-    @break = produce(Break)
-    @break.id = 1
-  end
+module ParadeiserTest
+  class TestBreakView < ViewTest
+    def setup
+      super
+      @break = produce(Break)
+      @break.id = 1
+    end
 
-  def test_start
-    assert_match(/^Started a new break \(5 minutes\)\.$/m, render(:start))
-  end
+    def test_start
+      assert_match(/^Started a new break \(5 minutes\)\.$/m, render(:start))
+    end
 
-  def test_finish
-    assert_match(/^Finished break #1 after .* minutes\.$/m, render(:finish))
-  end
+    def test_finish
+      assert_match(/^Finished break #1 after .* minutes\.$/m, render(:finish))
+    end
 
-protected
+  protected
 
-  def model
-    'Break'
+    def model
+      'Break'
+    end
   end
 end

data/test/unit/test_breaks_controller.rb

@@ -1,66 +1,69 @@
 require 'helper'
 
-class TestBreaksController < ControllerTest
-  def setup
-    @backend = PStoreMock.new
-  end
-
-  def model
-    'break'
-  end
+module ParadeiserTest
+  class TestBreaksController < ControllerTest
+    def setup
+      super
+      @backend = PStoreMock.new
+    end
 
-  def test_break
-    attrs = invoke(:start, nil, nil, '@break', 'exitstatus', 'has_output')
-    assert_equal(:active, attrs[:break].status_name)
-    assert_equal(false, attrs[:has_output])
-    assert_empty(attrs[:stdout])
-    assert_empty(attrs[:stderr])
-    assert_equal(1, @backend.size)
-  end
+    def model
+      'break'
+    end
 
-  def test_break_verbose
-    attrs = invoke(:start, nil, OpenStruct.new(:verbose => true), '@break', 'exitstatus', 'has_output')
-    assert_equal(:active, attrs[:break].status_name)
-    assert_equal(false, attrs[:has_output])
-    refute_empty(attrs[:stdout])
-    assert_empty(attrs[:stderr])
-    assert_equal(1, @backend.size)
-  end
+    def test_break
+      attrs = invoke(:start, nil, nil, '@break', 'exitstatus', 'has_output')
+      assert_equal(:active, attrs[:break].status_name)
+      assert_equal(false, attrs[:has_output])
+      assert_empty(attrs[:stdout])
+      assert_empty(attrs[:stderr])
+      assert_equal(1, @backend.size)
+    end
 
-  def test_break_active
-    invoke(:start)
-    assert_equal(1, @backend.size)
+    def test_break_verbose
+      attrs = invoke(:start, nil, OpenStruct.new(:verbose => true), '@break', 'exitstatus', 'has_output')
+      assert_equal(:active, attrs[:break].status_name)
+      assert_equal(false, attrs[:has_output])
+      refute_empty(attrs[:stdout])
+      assert_empty(attrs[:stderr])
+      assert_equal(1, @backend.size)
+    end
 
-    assert_raises SingletonError do
+    def test_break_active
       invoke(:start)
+      assert_equal(1, @backend.size)
+
+      assert_raises SingletonError do
+        invoke(:start)
+      end
+      assert_equal(1, @backend.size)
     end
-    assert_equal(1, @backend.size)
-  end
 
-  def test_finish
-    invoke(:start)
-    attrs = invoke(:finish, nil, nil, '@break', 'exitstatus', 'has_output')
-    assert_equal(:finished, attrs[:break].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
+      invoke(:start)
+      attrs = invoke(:finish, nil, nil, '@break', 'exitstatus', 'has_output')
+      assert_equal(:finished, attrs[:break].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), '@break', 'exitstatus', 'has_output')
-    assert_equal(:finished, attrs[:break].status_name)
-    assert_equal(false, attrs[:has_output])
-    refute_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), '@break', 'exitstatus', 'has_output')
+      assert_equal(:finished, attrs[:break].status_name)
+      assert_equal(false, attrs[:has_output])
+      refute_empty(attrs[:stdout])
+      assert_empty(attrs[:stderr])
+      assert_equal(1, @backend.size)
+    end
 
-  def test_finish_idle
-    assert_raises NotActiveError do
-      invoke(:finish)
+    def test_finish_idle
+      assert_raises NotActiveError do
+        invoke(:finish)
+      end
+      assert_equal(0, @backend.size)
     end
-    assert_equal(0, @backend.size)
   end
 end