rails--rails/activesupport/test/evented_file_update_checker_test.rb

require 'abstract_unit'
require 'pathname'
require 'file_update_checker_shared_tests'

class EventedFileUpdateCheckerTest < ActiveSupport::TestCase
  include FileUpdateCheckerSharedTests

  def setup
    skip if ENV['LISTEN'] == '0'
    super
  end

  def new_checker(files = [], dirs = {}, &block)
    ActiveSupport::EventedFileUpdateChecker.new(files, dirs, &block).tap do |c|
      wait
    end
  end

  def teardown
    super
    Listen.stop
  end

  def wait
    sleep 1
  end

  def touch(files)
    super
    wait # wait for the events to fire
  end

  def rm_f(files)
    super
    wait
  end

  test 'notifies forked processes' do
    FileUtils.touch(tmpfiles)

    checker = new_checker(tmpfiles) { }
    assert !checker.updated?

    # Pipes used for flow controll across fork.
    boot_reader,  boot_writer  = IO.pipe
    touch_reader, touch_writer = IO.pipe

    pid = fork do
      assert checker.updated?

      # Clear previous check value.
      checker.execute
      assert !checker.updated?

      # Fork is booted, ready for file to be touched
      # notify parent process.
      boot_writer.write("booted")

      # Wait for parent process to signal that file
      # has been touched.
      IO.select([touch_reader])

      assert checker.updated?
    end

    assert pid

    # Wait for fork to be booted before touching files.
    IO.select([boot_reader])
    touch(tmpfiles)

    # Notify fork that files have been touched.
    touch_writer.write("touched")

    assert checker.updated?

    Process.wait(pid)
  end
end

class EventedFileUpdateCheckerPathHelperTest < ActiveSupport::TestCase
  def pn(path)
    Pathname.new(path)
  end

  setup do
    @ph = ActiveSupport::EventedFileUpdateChecker::PathHelper.new
  end

  test '#xpath returns the expanded path as a Pathname object' do
    assert_equal pn(__FILE__).expand_path, @ph.xpath(__FILE__)
  end

  test '#normalize_extension returns a bare extension as is' do
    assert_equal 'rb', @ph.normalize_extension('rb')
  end

  test '#normalize_extension removes a leading dot' do
    assert_equal 'rb', @ph.normalize_extension('.rb')
  end

  test '#normalize_extension supports symbols' do
    assert_equal 'rb', @ph.normalize_extension(:rb)
  end

  test '#longest_common_subpath finds the longest common subpath, if there is one' do
    paths = %w(
      /foo/bar
      /foo/baz
      /foo/bar/baz/woo/zoo
    ).map { |path| pn(path) }

    assert_equal pn('/foo'), @ph.longest_common_subpath(paths)
  end

  test '#longest_common_subpath returns the root directory as an edge case' do
    paths = %w(
      /foo/bar
      /foo/baz
      /foo/bar/baz/woo/zoo
      /wadus
    ).map { |path| pn(path) }

    assert_equal pn('/'), @ph.longest_common_subpath(paths)
  end

  test '#longest_common_subpath returns nil for an empty collection' do
    assert_nil @ph.longest_common_subpath([])
  end

  test '#existing_parent returns the most specific existing ascendant' do
    wd = Pathname.getwd

    assert_equal wd, @ph.existing_parent(wd)
    assert_equal wd, @ph.existing_parent(wd.join('non-existing/directory'))
    assert_equal pn('/'), @ph.existing_parent(pn('/non-existing/directory'))
  end

  test '#filter_out_descendants returns the same collection if there are no descendants (empty)' do
    assert_equal [], @ph.filter_out_descendants([])
  end

  test '#filter_out_descendants returns the same collection if there are no descendants (one)' do
    assert_equal ['/foo'], @ph.filter_out_descendants(['/foo'])
  end

  test '#filter_out_descendants returns the same collection if there are no descendants (several)' do
    paths = %w(
      /Rails.root/app/controllers
      /Rails.root/app/models
      /Rails.root/app/helpers
    ).map { |path| pn(path) }

    assert_equal paths, @ph.filter_out_descendants(paths)
  end

  test '#filter_out_descendants filters out descendants preserving order' do
    paths = %w(
      /Rails.root/app/controllers
      /Rails.root/app/controllers/concerns
      /Rails.root/app/models
      /Rails.root/app/models/concerns
      /Rails.root/app/helpers
    ).map { |path| pn(path) }

    assert_equal paths.values_at(0, 2, 4), @ph.filter_out_descendants(paths)
  end

  test '#filter_out_descendants works on path units' do
    paths = %w(
      /foo/bar
      /foo/barrrr
    ).map { |path| pn(path) }

    assert_equal paths, @ph.filter_out_descendants(paths)
  end

  test '#filter_out_descendants deals correctly with the root directory' do
    paths = %w(
      /
      /foo
      /foo/bar
    ).map { |path| pn(path) }

    assert_equal paths.values_at(0), @ph.filter_out_descendants(paths)
  end

  test '#filter_out_descendants preserves duplicates' do
    paths = %w(
      /foo
      /foo/bar
      /foo
    ).map { |path| pn(path) }

    assert_equal paths.values_at(0, 2), @ph.filter_out_descendants(paths)
  end
end