wake 0.1.0

data/test/event_handlers/test_rev.rb

@@ -0,0 +1,162 @@
+require 'test/test_helper'
+
+if HAVE_REV
+
+class Wake::EventHandler::Rev::SingleFileWatcher
+  public :type
+end
+
+class RevEventHandlerTest < Test::Unit::TestCase
+  include Wake
+
+  SingleFileWatcher = EventHandler::Rev::SingleFileWatcher
+
+  def setup
+    @now = Time.now
+    pathname = Pathname.new('foo/bar')
+    pathname.stubs(:atime ).returns(@now)
+    pathname.stubs(:mtime ).returns(@now)
+    pathname.stubs(:ctime ).returns(@now)
+    pathname.stubs(:exist?).returns(true)
+    SingleFileWatcher.any_instance.stubs(:pathname).returns(pathname)
+
+    @loop    = Rev::Loop.default
+    @handler = EventHandler::Rev.new
+    @watcher = SingleFileWatcher.new('foo/bar')
+    @loop.stubs(:run)
+  end
+
+  def teardown
+    SingleFileWatcher.handler = nil
+    Rev::Loop.default.watchers.every.detach
+  end
+
+  test "triggers listening state" do
+    @loop.expects(:run)
+    @handler.listen([])
+  end
+
+  ## SingleFileWatcher
+
+  test "watcher pathname" do
+    @watcher.pathname.should be_kind_of(Pathname)
+    @watcher.pathname.to_s.should be(@watcher.path)
+  end
+
+  test "stores reference times" do
+    @watcher.pathname.stubs(:atime).returns(:time)
+    @watcher.pathname.stubs(:mtime).returns(:time)
+    @watcher.pathname.stubs(:ctime).returns(:time)
+
+    @watcher.send(:update_reference_times)
+    @watcher.instance_variable_get(:@reference_atime).should be(:time)
+    @watcher.instance_variable_get(:@reference_mtime).should be(:time)
+    @watcher.instance_variable_get(:@reference_ctime).should be(:time)
+  end
+
+  test "stores initial reference times" do
+    SingleFileWatcher.any_instance.expects(:update_reference_times)
+    SingleFileWatcher.new('foo')
+  end
+
+  test "updates reference times on change" do
+    @watcher.expects(:update_reference_times)
+    @watcher.on_change
+  end
+
+  test "detects event type" do
+    trigger_event @watcher, @now, :atime
+    @watcher.type.should be(:accessed)
+
+    trigger_event @watcher, @now, :mtime
+    @watcher.type.should be(:modified)
+
+    trigger_event @watcher, @now, :ctime
+    @watcher.type.should be(:changed)
+
+    trigger_event @watcher, @now, :atime, :mtime
+    @watcher.type.should be(:modified)
+
+    trigger_event @watcher, @now, :mtime, :ctime
+    @watcher.type.should be(:modified)
+
+    trigger_event @watcher, @now, :atime, :ctime
+    @watcher.type.should be(:accessed)
+
+    trigger_event @watcher, @now, :atime, :mtime, :ctime
+    @watcher.type.should be(:modified)
+
+    @watcher.pathname.stubs(:exist?).returns(false)
+    @watcher.type.should be(:deleted)
+  end
+
+  ## monitoring file events
+
+  test "listens for events on monitored files" do
+    @handler.listen %w( foo bar )
+    @loop.watchers.size.should be(2)
+    @loop.watchers.every.path.should include('foo', 'bar')
+    @loop.watchers.every.class.uniq.should be([SingleFileWatcher])
+  end
+
+  test "notifies observers on file event" do
+    @watcher.stubs(:path).returns('foo')
+    @handler.expects(:notify).with('foo', anything)
+    @watcher.on_change
+  end
+
+  test "notifies observers of event type" do
+    trigger_event @watcher, @now, :atime
+    @handler.expects(:notify).with('foo/bar', :accessed)
+    @watcher.on_change
+
+    trigger_event @watcher, @now, :mtime
+    @handler.expects(:notify).with('foo/bar', :modified)
+    @watcher.on_change
+
+    trigger_event @watcher, @now, :ctime
+    @handler.expects(:notify).with('foo/bar', :changed)
+    @watcher.on_change
+
+    trigger_event @watcher, @now, :atime, :mtime, :ctime
+    @handler.expects(:notify).with('foo/bar', :modified)
+    @watcher.on_change
+
+    @watcher.pathname.stubs(:exist?).returns(false)
+    @handler.expects(:notify).with('foo/bar', :deleted)
+    @watcher.on_change
+  end
+
+  ## on the fly updates of monitored files list
+
+  test "reattaches to new monitored files" do
+    @handler.listen %w( foo bar )
+    @loop.watchers.size.should be(2)
+    @loop.watchers.every.path.should include('foo')
+    @loop.watchers.every.path.should include('bar')
+
+    @handler.refresh %w( baz bax )
+    @loop.watchers.size.should be(2)
+    @loop.watchers.every.path.should include('baz')
+    @loop.watchers.every.path.should include('bax')
+    @loop.watchers.every.path.should exclude('foo')
+    @loop.watchers.every.path.should exclude('bar')
+  end
+
+  private
+
+  def trigger_event(watcher, now, *types)
+    watcher.pathname.stubs(:atime).returns(now)
+    watcher.pathname.stubs(:mtime).returns(now)
+    watcher.pathname.stubs(:ctime).returns(now)
+    watcher.instance_variable_set(:@reference_atime, now)
+    watcher.instance_variable_set(:@reference_mtime, now)
+    watcher.instance_variable_set(:@reference_ctime, now)
+
+    types.each do |type|
+      watcher.pathname.stubs(type).returns(now+10)
+    end
+  end
+end
+
+end  # HAVE_REV

data/test/test_controller.rb

@@ -0,0 +1,130 @@
+require 'test/test_helper'
+require 'observer'
+
+class MockHandler
+  include Observable
+  def listen(paths)  end
+  def refresh(paths) end
+end
+
+class TestController < Test::Unit::TestCase
+  include Wake
+
+  def to_p(str)
+    Pathname(str).expand_path
+  end
+
+  def setup
+    tmpfile     = Tempfile.new('foo')
+    @script     = Script.new( Pathname.new( tmpfile.path ) )
+    @handler    = MockHandler.new
+    Wake.stubs(:handler).returns(MockHandler)
+    MockHandler.stubs(:new).returns(@handler)
+    @controller = Controller.new(@script)
+  end
+
+  test "triggers listening state on run" do
+    @controller.stubs(:monitored_paths).returns %w( foo bar )
+    @handler.expects(:listen).with %w( foo bar )
+    @controller.run
+  end
+
+  test "parses the script on #run" do
+    @script.expects(:parse!)
+    @controller.run
+  end
+
+  test "adds itself as handler observer" do
+    @controller.handler
+    @handler.count_observers.should be(1)
+    @handler.delete_observer(@controller)
+    @handler.count_observers.should be(0)
+  end
+
+  ## monitored paths list
+
+  test "fetches monitored paths" do
+    Dir.expects(:[]).at_least_once.with('**/*').returns(%w(
+      a
+      b/x.z
+      b/c
+      b/c/y.z
+    ))
+    @script.watch('.\.z') { :x }
+
+    contrl = Controller.new(@script)
+    contrl.monitored_paths.should include(to_p('b/x.z'))
+    contrl.monitored_paths.should include(to_p('b/c/y.z'))
+  end
+
+  test "doesn't fetch unmonitored paths" do
+    Dir.expects(:[]).at_least_once.with('**/*').returns(%w(
+      a
+      b/x.z
+      b/c
+      b/c/y.z
+    ))
+    @script.watch('.\.z') { :x }
+
+    contrl = Controller.new(@script)
+    contrl.monitored_paths.should exclude(to_p('a'))
+    contrl.monitored_paths.should exclude(to_p('b/c'))
+    contrl.monitored_paths.should exclude(to_p('p/q.z'))
+  end
+
+  test "monitored paths include script" do
+    Dir.expects(:[]).at_least_once.with('**/*').returns(%w( a ))
+    Script.any_instance.stubs(:parse!)
+
+    path   = to_p('some/file')
+    script = Script.new(path)
+    contrl = Controller.new(script)
+    contrl.monitored_paths.should include(path)
+  end
+
+  ## on update
+
+  test "calls action for path" do
+    path = to_p('abc')
+    @script.expects(:call_action_for).with(path, :modified).returns(nil)
+
+    @controller.update('abc', :modified)
+  end
+
+  test "parses script on script file update" do
+    path = to_p('abc')
+    @script.stubs(:path).returns(path)
+    @script.expects(:parse!)
+
+    @controller.update('abc')
+  end
+
+  test "refreshes handler on script file update" do
+    path = to_p('abc')
+    @script.stubs(:path).returns(path)
+    @controller.stubs(:monitored_paths).returns %w( foo bar )
+
+    @handler.expects(:refresh).with %w( foo bar )
+    @controller.update(path)
+  end
+
+  test "refreshes handler on script action exception" do
+    path = to_p('abc')
+    @script.stubs(:path).returns(path)
+
+    file = to_p('012')
+    @script.expects(:call_action_for).with(file,nil).raises(Wake::Refresh)
+
+    @controller.stubs(:monitored_paths).returns %w( foo bar )
+
+    @handler.expects(:refresh).with %w( foo bar )
+
+    @controller.update(file)
+  end
+
+  test "exits gracefully when Interrupted" do
+    @handler.stubs(:listen).raises(Interrupt)
+    @controller.run
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,60 @@
+require 'pathname'
+require 'tempfile'
+require 'test/unit'
+
+require 'matchy'
+require 'mocha'
+require 'every'
+require 'pending'
+begin
+  require 'redgreen'
+  require 'phocus'
+  require 'ruby-debug'
+rescue LoadError, RuntimeError
+end
+
+root = Pathname(__FILE__).dirname.parent.expand_path
+$:.unshift(root.join('lib').to_s).uniq!
+
+require 'wake'
+
+class Test::Unit::TestCase
+  class << self
+    def test(name, &block)
+      name = :"test_#{name.gsub(/\s/,'_')}"
+      define_method(name, &block)
+    end
+    alias :should :test
+
+    # noop
+    def xtest(*args) end
+  end
+end
+
+# taken from minitest/unit.rb
+# (with modifications)
+def capture_io
+  require 'stringio'
+
+  orig_stdout, orig_stderr         = $stdout, $stderr
+  captured_stdout, captured_stderr = StringIO.new, StringIO.new
+  $stdout, $stderr                 = captured_stdout, captured_stderr
+
+  yield
+
+  return Struct.new(:stdout, :stderr).new(
+    captured_stdout.string,
+    captured_stderr.string
+  )
+ensure
+  $stdout = orig_stdout
+  $stderr = orig_stderr
+end
+
+begin
+  require "wake/event_handlers/rev"
+  HAVE_REV = true
+rescue LoadError
+  HAVE_REV = false
+end
+

data/test/test_script.rb

@@ -0,0 +1,124 @@
+require 'test/test_helper'
+
+class TestScript < Test::Unit::TestCase
+  include Wake
+
+  def setup
+    tmpfile = Tempfile.new('foo')
+    @script = Script.new( Pathname.new( tmpfile.path ) )
+  end
+
+  ## external api
+
+  test "watch" do
+    @script.watch('pattern')
+    @script.watch('pattern', :event_type)
+    @script.watch('pattern') { nil }
+  end
+
+  test "default action" do
+    @script.default_action { nil }
+  end
+
+  ## functionality
+
+  test "rule object" do
+    rule = @script.watch('pattern', :modified) { nil }
+    rule.pattern.should be('pattern')
+    rule.event_types[0].should be(:modified)
+    rule.action.call.should be(nil)
+  end
+
+  test "default event type" do
+    rule = @script.watch('pattern') { nil }
+    rule.event_types[0].should be(:modified)
+  end
+
+  test "finds action for path" do
+    @script.watch('abc') { :x }
+    @script.watch('def') { :y }
+    @script.call_action_for('abc').should be(:x)
+  end
+
+  test "finds action for path with event type" do
+    @script.watch('abc', :accessed) { :x }
+    @script.watch('abc', :modified) { :y }
+    @script.call_action_for('abc', :accessed).should be(:x)
+  end
+
+  test "finds action for path with any event type" do
+    @script.watch('abc', nil) { :x }
+    @script.watch('abc', :modified) { :y }
+    @script.call_action_for('abc', :accessed).should be(:x)
+  end
+
+  test "no action for path" do
+    @script.watch('abc', :accessed) { :x }
+    @script.call_action_for('abc', :modified).should be(nil)
+  end
+
+  test "collects patterns" do
+    @script.watch('abc')
+    @script.watch('def')
+    @script.patterns.should include('abc')
+    @script.patterns.should include('def')
+  end
+
+  test "parses script file" do
+    file = Pathname( Tempfile.open('bar').path )
+    file.open('w') {|f| f.write <<-STR }
+      watch( 'abc' ) { :x }
+    STR
+    script = Script.new(file)
+    script.parse!
+    script.call_action_for('abc').should be(:x)
+  end
+
+  test "resets state" do
+    @script.default_action { 'x' }
+    @script.watch('foo') { 'bar' }
+    @script.send(:reset)
+    @script.instance_variable_get(:@default_action).call.should be(nil)
+    @script.instance_variable_get(:@rules).should be([])
+  end
+
+  test "resets state on parse" do
+    @script.stubs(:instance_eval)
+    @script.expects(:reset)
+    @script.parse!
+  end
+
+  test "actions receive a MatchData object" do
+    @script.watch('de(.)') {|m| [m[0], m[1]] }
+    @script.call_action_for('def').should be(%w( def f ))
+  end
+
+  test "rule's default action" do
+    @script.watch('abc')
+    @script.call_action_for('abc').should be(nil)
+    @script.default_action { :x }
+
+    @script.watch('def')
+    @script.call_action_for('def').should be(:x)
+  end
+
+  test "file path" do
+    Script.any_instance.stubs(:parse!)
+    path   = Pathname('some/file').expand_path
+    script = Script.new(path)
+    script.path.should be(path)
+  end
+
+  test "later rules take precedence" do
+    @script.watch('a/(.*)\.x')   { :x }
+    @script.watch('a/b/(.*)\.x') { :y }
+
+    @script.call_action_for('a/b/c.x').should be(:y)
+  end
+
+  test "rule patterns match against paths relative to pwd" do
+    @script.watch('^abc') { :x }
+    path = Pathname(Dir.pwd) + 'abc'
+    @script.call_action_for(path).should be(:x)
+  end
+end