paradeiser 0.2.0 → 0.4.0

data/test/integration/test_annotate.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+class TestAnnotateCommand < Paradeiser::IntegrationTest
+  def test_annotate_no_previous
+    refute_command('annotate')
+  end
+
+  def test_annotate_active
+    assert_command('start')
+    assert_command('annotate', 0, name.split('_'))
+  end
+
+  def test_annotate_second_last_successful
+    assert_command('start')
+    assert_command('finish')
+    assert_command('break')
+    assert_command('annotate', 0, name.split('_'))
+  end
+end

data/test/integration/test_finish.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class TestFinishCommand < Paradeiser::IntegrationTest
+  def test_finish
+    refute_command('finish')
+    assert_command('start')
+    assert_command('finish')
+  end
+end

data/test/integration/test_interrupt.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class TestInterruptCommand < Paradeiser::IntegrationTest
+  def test_interrupt
+    refute_command('interrupt')
+    assert_command('start')
+    assert_command('interrupt')
+  end
+end

data/test/integration/test_log.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+class TestLogCommand < Paradeiser::IntegrationTest
+  def test_log_inactive
+    assert_command('log', 0, name.split('_'))
+  end
+
+  def test_log_active
+    assert_command('start')
+    assert_command('log', 0, name.split('_'))
+  end
+end

data/test/integration/test_no_args.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestNoArgsCommand < Paradeiser::IntegrationTest
+  def test_no_args
+    assert_command('')
+  end
+end

data/test/integration/test_start.rb

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

data/test/integration/test_status.rb

@@ -0,0 +1,10 @@
+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")
+  end
+end

data/test/integration/test_unknown.rb

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

data/test/lib/at_mock.rb

@@ -1,6 +1,6 @@
 # Include this module in order to use another queue for at commands
 module Executor
   def queue
-    't'
+    ENV['PAR_AT_QUEUE'] || 't'
   end
 end

data/test/lib/controller_test.rb

@@ -0,0 +1,25 @@
+module Paradeiser
+  class ControllerTest < MiniTest::Test
+    def invoke(method, args = nil, options = nil, *attributes)
+      controller = Paradeiser.const_get("#{model.pluralize.capitalize}Controller".to_sym).new(method)
+
+      stdout, stderr = Repository.stub :backend, @backend do
+        Scheduler.stub(:add, nil) do
+          Scheduler.stub(:clear, nil) do
+            capture_io do
+              controller.call(Array(args), options)
+            end
+          end
+        end
+      end
+
+      result = Hash[attributes.map do |e|
+        [e.split('@').last.to_sym, controller.get_binding.eval(e)]
+      end]
+
+      result[:stdout] = stdout
+      result[:stderr] = stderr
+      result
+    end
+  end
+end

data/test/lib/integration_test.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+module Paradeiser
+  #
+  # 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.
+  #
+  class IntegrationTest < MiniTest::Test
+    PAR = 'bin/par'
+    include Executor
+
+    def setup
+      if Scheduler.list.any?
+        @do_not_clear = true
+        raise "The at queue '#{queue}' is not empty. Clean it up before running this test again."
+      end
+
+      @orig_PAR_DIR = ENV['PAR_DIR']
+      ENV['PAR_DIR'] = Dir.mktmpdir
+      ENV['PAR_AT_QUEUE'] = 'i'
+      assert_command('init')
+    end
+
+    def teardown
+      FileUtils.rm_rf(Paradeiser.par_dir)
+      ENV['PAR_DIR'] = @orig_PAR_DIR
+      Scheduler.clear unless @do_not_clear
+      raise "The at queue #{queue} is not empty. Clean it up before running this test again." if Scheduler.list.any?
+      ENV.delete('PAR_AT_QUEUE')
+    end
+
+    def assert_command(cmd, expected_status = 0, *args)
+      out, err, status = Open3.capture3("#{PAR} #{cmd} #{Shellwords.join(args)}")
+      assert_equal(expected_status, status.exitstatus, "Expected exit status to be #{expected_status}, but it was #{status.exitstatus}. STDERR is: '#{err}'")
+      assert_empty(err)
+      out
+    end
+
+    def refute_command(cmd, expected_status = 1, *args)
+      out, err, status = Open3.capture3("#{PAR} #{cmd}")
+      assert_equal(expected_status, status.exitstatus, "Expected exit status to be #{expected_status}, but it was #{status.exitstatus}.")
+      [out, err]
+    end
+  end
+end

data/test/lib/paradeiser_controller_test.rb

@@ -0,0 +1,7 @@
+module Paradeiser
+  class ParadeiserControllerTest < ControllerTest
+    def model
+      'paradeiser'
+    end
+  end
+end

data/test/lib/view_test.rb

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

data/test/unit/test_break.rb

@@ -2,26 +2,14 @@ require 'helper'
 
 class TestBreak < MiniTest::Test
   def setup
-    @break = Break.new
+    @break = produce(Break)
   end
 
-  def test_virgin
-    assert_equal(:idle, @break.status_name)
-  end
-
-  def test_break
-    start!
+  def test_new
     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
@@ -38,43 +26,25 @@ class TestBreak < MiniTest::Test
     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)
+    later = @started + rand(42)
 
     Time.stub :now, Time.at(later) do
-      assert_equal(later - now, @break.duration)
+      assert_equal(later - @started, @break.duration)
     end
   end
 
   def test_duration_finished
-    now = srand
-
-    Time.stub :now, Time.at(now) do
-      start!
-    end
-
-    later = now + rand(42)
+    later = @started + rand(42)
 
     Time.stub :now, Time.at(later) do
       finish!
     end
 
-    assert_equal(later - now, @break.duration)
+    assert_equal(later - @started, @break.duration)
   end
 
   def test_finish_break
-    start!
     finish!
     assert_raises StateMachine::InvalidTransition do
       finish!
@@ -82,15 +52,8 @@ class TestBreak < MiniTest::Test
   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
+    later = @started + delta
 
     Time.stub :now, Time.at(later) do
       assert_equal(@break.length - delta, @break.remaining)

data/test/unit/test_break_view.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+class TestBreakView < ViewTest
+  def setup
+    @break = produce(Break)
+    @break.id = 1
+  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
+
+protected
+
+  def model
+    'Break'
+  end
+end

data/test/unit/test_breaks_controller.rb

@@ -0,0 +1,66 @@
+require 'helper'
+
+class TestBreaksController < ControllerTest
+  def setup
+    @backend = PStoreMock.new
+  end
+
+  def model
+    'break'
+  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_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_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)
+    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_idle
+    assert_raises NotActiveError do
+      invoke(:finish)
+    end
+    assert_equal(0, @backend.size)
+  end
+end

data/test/unit/test_paradeiser_controller_export.rb

@@ -0,0 +1,107 @@
+require 'helper'
+
+#
+# There is no view for export, so we need to test the entire results here
+#
+class TestParadeiserControllerExport < ParadeiserControllerTest
+  def setup
+    @backend = PStoreMock.new
+  end
+
+  def test_empty
+    attrs = invoke(:export)
+    assert_empty(attrs[:stderr])
+
+    result = JSON.parse(attrs[:stdout])
+    assert(result)
+    assert_empty(result)
+  end
+
+  def test_pomodoro
+    pom = produce(Pomodoro)
+    started_at = Time.new(8)
+    pom.started_at = started_at
+    pom.finish!
+    finished_at = Time.new(16)
+    pom.finished_at = finished_at
+    @backend[:bar] = pom
+
+    attrs = invoke(:export)
+    assert_empty(attrs[:stderr])
+    result = JSON.parse(attrs[:stdout])
+
+    assert(result)
+    refute_empty(result)
+    assert_equal(1, result.size)
+    p = result.first
+    assert(p)
+
+    assert_equal('Pomodoro', p['type'])
+    assert_equal(1500, p['length'])
+    assert_equal('finished', p['status'])
+    assert_equal(started_at.as_json, p['started_at'])
+    assert_equal(finished_at.as_json, p['finished_at'])
+
+    interrupts = p['interrupts']
+    assert(interrupts)
+    assert_empty(interrupts)
+
+    annotations = p['annotations']
+    assert(annotations)
+    assert_empty(annotations)
+  end
+
+  def test_break
+    br3ak = produce(Break)
+    started_at = Time.new(8)
+    br3ak.started_at = started_at
+    br3ak.finish!
+    finished_at = Time.new(16)
+    br3ak.finished_at = finished_at
+    @backend[:bar] = br3ak
+
+    attrs = invoke(:export)
+    assert_empty(attrs[:stderr])
+    result = JSON.parse(attrs[:stdout])
+
+    assert(result)
+    refute_empty(result)
+    assert_equal(1, result.size)
+    p = result.first
+    assert(p)
+
+    assert_equal('Break', p['type'])
+    assert_equal(300, p['length'])
+    assert_equal('finished', p['status'])
+    assert_equal(started_at.as_json, p['started_at'])
+    assert_equal(finished_at.as_json, p['finished_at'])
+
+    refute(p['interrupts'])
+    refute(p['annotations'])
+  end
+
+  def test_multiple
+    br3ak = produce(Break)
+    br3ak.started_at = Time.new(8)
+    br3ak.finish!
+    br3ak.finished_at = Time.new(16)
+    @backend[:bar] = br3ak
+
+    pom = produce(Pomodoro)
+    pom.started_at = Time.new(8)
+    pom.finish!
+    pom.finished_at = Time.new(16)
+    @backend[:foo] = pom
+
+    attrs = invoke(:export)
+    assert_empty(attrs[:stderr])
+    result = JSON.parse(attrs[:stdout])
+
+    assert(result)
+    refute_empty(result)
+    assert_equal(2, result.size)
+
+    assert_equal('Break', result.first['type'])
+    assert_equal('Pomodoro', result.last['type'])
+  end
+end