paradeiser 0.4.0 → 0.5.0

data/test/unit/test_interrupt.rb

@@ -1,36 +1,39 @@
 require 'helper'
 
-class TestInterrupt < MiniTest::Test
-  def setup
-    @now = srand
-  end
+module ParadeiserTest
+  class TestInterrupt < UnitTest
+    def setup
+      super
+      @now = srand
+    end
 
-  def test_created_at
-    int = new_interrupt
-    assert_equal(@now, int.created_at.to_i)
-  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_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_external
+      int = new_interrupt(:external)
+      assert_equal(:external, int.type)
+    end
 
-  def test_unknown
-    assert_raises InvalidTypeError do
-      new_interrupt(:unknown)
+    def test_unknown
+      assert_raises InvalidTypeError do
+        new_interrupt(:unknown)
+      end
     end
-  end
 
-private
+  private
 
-  def new_interrupt(type = nil)
-    Time.stub :now, Time.at(@now) do
-      Paradeiser::Interrupt.new(type)
+    def new_interrupt(type = nil)
+      Time.stub :now, Time.at(@now) do
+        Paradeiser::Interrupt.new(type)
+      end
     end
   end
 end

data/test/unit/test_paradeiser_controller_export.rb

@@ -3,105 +3,108 @@ 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'])
+module ParadeiserTest
+  class TestParadeiserControllerExport < ParadeiserControllerTest
+    def setup
+      super
+      @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
 end

data/test/unit/test_paradeiser_controller_init.rb

@@ -26,7 +26,7 @@ class TestParadeiserControllerInit < MiniTest::Test
   end
 
   def test_init_existing
-    FileUtils.mkdir_p(Paradeiser.par_dir, 0700)
+    FileUtils.mkdir_p(Paradeiser.par_dir, mode: 0700)
     assert(Dir.exists?(Paradeiser.par_dir))
 
     invoke(:init)
@@ -50,7 +50,7 @@ class TestParadeiserControllerInit < MiniTest::Test
   def test_init_existing_with_env_override
     ENV.delete('PAR_DIR')
 
-    Dir.mktmpdir do |dir|
+    Dir.mktmpdir(name) do |dir|
       refute_equal(dir, Paradeiser.par_dir)
       ENV['PAR_DIR'] = dir
       assert_equal(dir, Paradeiser.par_dir)

data/test/unit/test_paradeiser_controller_report.rb

@@ -1,91 +1,94 @@
 require 'helper'
 
-class TestParadeiserControllerReport < ParadeiserControllerTest
-  ATTR_NAMES = %w{has_output @finished @canceled @external_interrupts @internal_interrupts @breaks @break_minutes}
+module ParadeiserTest
+  class TestParadeiserControllerReportTest < ParadeiserControllerTest
+    ATTR_NAMES = %w{has_output @finished @canceled @external_interrupts @internal_interrupts @breaks @break_minutes}
 
-  def setup
-    @backend = PStoreMock.new
-  end
+    def setup
+      super
+      @backend = PStoreMock.new
+    end
 
-  def test_idle
-    attrs = invoke(:report, nil, nil, *ATTR_NAMES)
-    assert_equal(0, attrs[:finished])
-  end
+    def test_idle
+      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_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
+    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
+      attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+      assert_equal(1, attrs[:finished])
+    end
 
-  def test_canceled
-    pom = produce(Pomodoro)
-    pom.started_at = Time.new(16)
-    pom.canceled_at = Time.new(24)
-    pom.cancel!
-    @backend[:bar] = pom
+    def test_canceled
+      pom = produce(Pomodoro)
+      pom.started_at = Time.new(16)
+      pom.canceled_at = Time.new(24)
+      pom.cancel!
+      @backend[:bar] = pom
 
-    attrs = invoke(:report, nil, nil, *ATTR_NAMES)
-    assert_equal(1, attrs[:canceled])
-  end
+      attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+      assert_equal(1, attrs[:canceled])
+    end
 
-  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
+    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
+      attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+      assert_equal(1, attrs[:external_interrupts])
+    end
 
-  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
+    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
+      attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+      assert_equal(1, attrs[:internal_interrupts])
+    end
 
-  def test_breaks
-    br3ak = produce(Break)
-    br3ak.started_at = Time.new(164)
-    br3ak.finished_at = Time.new(128)
-    @backend[:foo] = br3ak
+    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
+      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)
+    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
+      attrs = invoke(:report, nil, nil, *ATTR_NAMES)
+      assert_equal(10, attrs[:break_minutes])
+    end
 
-private
+  private
 
-  def make_break(minutes = 5)
-    Break.new.tap do |b|
-      b.started_at = srand
-      b.finished_at = b.started_at + minutes * 60
+    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
 end