observr 1.0

data/test/event_handlers/test_portable.rb

@@ -0,0 +1,142 @@
+require 'test/test_helper'
+
+class Observr::EventHandler::Portable
+  attr_accessor :monitored_paths
+end
+
+class PortableEventHandlerTest < MiniTest::Unit::TestCase
+  include Observr
+
+  def setup
+    @handler = EventHandler::Portable.new
+    @handler.stubs(:loop)
+
+    @foo = Pathname('foo').expand_path
+    @bar = Pathname('bar').expand_path
+    @baz = Pathname('baz').expand_path
+    @bax = Pathname('bax').expand_path
+
+    @now = Time.now
+    [@foo, @bar, @baz, @bax].each do |path|
+      path.stubs(:mtime ).returns(@now - 100)
+      path.stubs(:atime ).returns(@now - 100)
+      path.stubs(:ctime ).returns(@now - 100)
+      path.stubs(:exist?).returns(true)
+    end
+  end
+
+  test "triggers listening state" do
+    @handler.expects(:loop)
+    @handler.listen([])
+  end
+
+  ## monitoring file events
+
+  test "listens for events on monitored files" do
+    @handler.listen [ @foo, @bar ]
+    assert_includes @handler.monitored_paths, @foo
+    assert_includes @handler.monitored_paths, @bar
+  end
+
+  test "doesn't trigger on start" do
+  end
+
+  ## event types
+
+  test "deleted file event" do
+    @foo.stubs(:exist?).returns(false)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :deleted)
+    @handler.trigger
+  end
+
+  test "modified file event" do
+    @foo.stubs(:mtime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :modified)
+    @handler.trigger
+  end
+
+  test "accessed file event" do
+    @foo.stubs(:atime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :accessed)
+    @handler.trigger
+  end
+
+  test "changed file event" do
+    @foo.stubs(:ctime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :changed)
+    @handler.trigger
+  end
+
+  ## event type priorities
+
+  test "mtime > atime" do
+    @foo.stubs(:mtime).returns(@now + 100)
+    @foo.stubs(:atime).returns(@now + 100)
+    @foo.stubs(:ctime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :modified)
+    @handler.trigger
+  end
+
+  test "mtime > ctime" do
+    @foo.stubs(:mtime).returns(@now + 100)
+    @foo.stubs(:ctime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :modified)
+    @handler.trigger
+  end
+
+  test "atime > ctime" do
+    @foo.stubs(:atime).returns(@now + 100)
+    @foo.stubs(:ctime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :accessed)
+    @handler.trigger
+  end
+
+  test "deleted > mtime" do
+    @foo.stubs(:exist?).returns(false)
+    @foo.stubs(:mtime ).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :deleted)
+    @handler.trigger
+  end
+
+  ## on the fly updates of monitored files list
+
+  test "reattaches to new monitored files" do
+    @handler.listen [ @foo, @bar ]
+    assert_includes @handler.monitored_paths, @foo
+    assert_includes @handler.monitored_paths, @bar
+
+    @handler.refresh [ @baz, @bax ]
+    assert_includes @handler.monitored_paths, @baz
+    assert_includes @handler.monitored_paths, @bax
+    refute_includes @handler.monitored_paths, @foo
+    refute_includes @handler.monitored_paths, @bar
+  end
+
+  test "retries on ENOENT errors" do
+    @oops = Pathname('oops').expand_path
+    @oops.stubs(:exist?).returns(true)
+    @oops.stubs(:mtime).raises(Errno::ENOENT).
+      then.returns(Time.now + 100)
+
+    @handler.listen [ @oops ]
+
+    @handler.expects(:notify).with(@oops, :modified)
+    @handler.trigger
+  end
+end

data/test/event_handlers/test_unix.rb

@@ -0,0 +1,162 @@
+require 'test/test_helper'
+
+if Observr::HAVE_REV
+
+class Observr::EventHandler::Unix::SingleFileWatcher
+  public :type
+end
+
+class UnixEventHandlerTest < MiniTest::Unit::TestCase
+  include Observr
+
+  SingleFileWatcher = EventHandler::Unix::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::Unix.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
+    assert_instance_of Pathname, @watcher.pathname
+    assert_equal @watcher.path, @watcher.pathname.to_s
+  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)
+    assert_equal :time, @watcher.instance_variable_get(:@reference_atime)
+    assert_equal :time, @watcher.instance_variable_get(:@reference_mtime)
+    assert_equal :time, @watcher.instance_variable_get(:@reference_ctime)
+  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
+    assert_equal :accessed, @watcher.type
+
+    trigger_event @watcher, @now, :mtime
+    assert_equal :modified, @watcher.type
+
+    trigger_event @watcher, @now, :ctime
+    assert_equal :changed, @watcher.type
+
+    trigger_event @watcher, @now, :atime, :mtime
+    assert_equal :modified, @watcher.type
+
+    trigger_event @watcher, @now, :mtime, :ctime
+    assert_equal :modified, @watcher.type
+
+    trigger_event @watcher, @now, :atime, :ctime
+    assert_equal :accessed, @watcher.type
+
+    trigger_event @watcher, @now, :atime, :mtime, :ctime
+    assert_equal :modified, @watcher.type
+
+    @watcher.pathname.stubs(:exist?).returns(false)
+    assert_equal :deleted, @watcher.type
+  end
+
+  ## monitoring file events
+
+  test "listens for events on monitored files" do
+    @handler.listen %w( foo bar )
+    assert_equal 2, @loop.watchers.size
+    assert_equal %w( foo bar ).to_set, @loop.watchers.every.path.to_set
+    assert_equal [SingleFileWatcher], @loop.watchers.every.class.uniq
+  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 )
+    assert_equal 2, @loop.watchers.size
+    assert_includes @loop.watchers.every.path, 'foo'
+    assert_includes @loop.watchers.every.path, 'bar'
+
+    @handler.refresh %w( baz bax )
+    assert_equal 2, @loop.watchers.size
+    assert_includes @loop.watchers.every.path, 'baz'
+    assert_includes @loop.watchers.every.path, 'bax'
+    refute_includes @loop.watchers.every.path, 'foo'
+    refute_includes @loop.watchers.every.path, '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  # if Observr::HAVE_REV

data/test/test_controller.rb

@@ -0,0 +1,121 @@
+require 'test/test_helper'
+require 'observer'
+
+class MockHandler
+  include Observable
+  def listen(paths)  end
+  def refresh(paths) end
+end
+
+class TestController < MiniTest::Unit::TestCase
+  include Observr
+
+  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
+    @controller = Controller.new(@script, @handler)
+  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
+    assert_equal 1, @handler.count_observers
+    @handler.delete_observer(@controller)
+    assert_equal 0, @handler.count_observers
+  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, MockHandler.new)
+    assert_includes contrl.monitored_paths, to_p('b/x.z')
+    assert_includes contrl.monitored_paths, 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, MockHandler.new)
+    refute_includes contrl.monitored_paths, to_p('a')
+    refute_includes contrl.monitored_paths, to_p('b/c')
+    refute_includes contrl.monitored_paths, 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, MockHandler.new)
+    assert_includes contrl.monitored_paths, path
+  end
+
+  ## on update
+
+  test "calls action for path" do
+    path = to_p('abc')
+    @script.expects(:action_for).with(path, :modified).returns(lambda {})
+
+    @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 "exits gracefully when Interrupted" do
+    @handler.stubs(:listen).raises(Interrupt)
+    @controller.run
+  end
+
+  test "does not parse script on mere script file access" do
+    path = to_p('abc')
+    @script.stubs(:path).returns(path)
+    @script.expects(:parse!).never
+
+    @controller.update('abc', :accessed)
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,37 @@
+require 'pathname'
+require 'tmpdir'
+require 'tempfile'
+require 'fileutils'
+
+require 'minitest/autorun'
+require 'mocha'
+require 'every'
+begin
+  require 'redgreen' #http://gemcutter.org/gems/mynyml-redgreen
+  require 'phocus'
+  require 'ruby-debug'
+rescue LoadError, RuntimeError
+end
+
+require 'observr'
+
+class MiniTest::Unit::TestCase
+  class << self
+    def test(name, &block)
+      define_method("test_#{name.gsub(/\s/,'_')}", &block)
+    end
+    alias :should :test
+
+    # noop
+    def xtest(*args) end
+  end
+end
+
+unless Observr::HAVE_REV
+  puts "Skipping Unix handler tests. Install Rev (gem install rev) to properly test full suite"
+end
+
+unless Observr::HAVE_FSE
+  puts "Skipping Darwin handler tests. Install FSEvent (gem install ruby-fsevent) to properly test full suite (osx only)"
+end
+