listen 2.7.5 → 2.7.6

data/spec/lib/listen/tcp/listener_spec.rb

@@ -1,45 +1,39 @@
 require 'spec_helper'
 
-describe Listen::TCP::Listener do
+require 'listen/tcp/message'
+require 'listen/tcp/broadcaster'
+
+describe Listen::Listener do
 
   let(:host) { '10.0.0.2' }
   let(:port) { 4000 }
 
   subject { described_class.new("#{host}:#{port}", :recipient, options) }
   let(:options) { {} }
-  let(:registry) { double(Celluloid::Registry, :[]= => true) }
+  let(:registry) { instance_double(Celluloid::Registry, :[]= => true) }
 
   let(:supervisor) do
-    double(Celluloid::SupervisionGroup, add: true, pool: true)
+    instance_double(Celluloid::SupervisionGroup, add: true, pool: true)
   end
 
-  let(:record) { double(Listen::Record, terminate: true, build: true) }
-  let(:silencer) { double(Listen::Silencer, terminate: true) }
-  let(:adapter) { double(Listen::Adapter::Base) }
-  let(:broadcaster) { double(Listen::TCP::Broadcaster) }
-  let(:change_pool) { double(Listen::Change, terminate: true) }
-  let(:change_pool_async) { double('ChangePoolAsync') }
+  let(:record) { instance_double(Listen::Record, terminate: true, build: true) }
+  let(:silencer) { instance_double(Listen::Silencer, terminate: true) }
+  let(:adapter) { instance_double(Listen::Adapter::Base) }
+  let(:async) { instance_double(Listen::TCP::Broadcaster, broadcast: true) }
+  let(:broadcaster) { instance_double(Listen::TCP::Broadcaster, async: async) }
+  let(:change_pool) { instance_double(Listen::Change, terminate: true) }
+  let(:change_pool_async) { instance_double('ChangePoolAsync') }
   before do
-    Celluloid::Registry.stub(:new) { registry }
-    Celluloid::SupervisionGroup.stub(:run!) { supervisor }
-    registry.stub(:[]).with(:silencer) { silencer }
-    registry.stub(:[]).with(:adapter) { adapter }
-    registry.stub(:[]).with(:record) { record }
-    registry.stub(:[]).with(:change_pool) { change_pool }
-    registry.stub(:[]).with(:broadcaster) { broadcaster }
+    allow(Celluloid::Registry).to receive(:new) { registry }
+    allow(Celluloid::SupervisionGroup).to receive(:run!) { supervisor }
+    allow(registry).to receive(:[]).with(:silencer) { silencer }
+    allow(registry).to receive(:[]).with(:adapter) { adapter }
+    allow(registry).to receive(:[]).with(:record) { record }
+    allow(registry).to receive(:[]).with(:change_pool) { change_pool }
+    allow(registry).to receive(:[]).with(:broadcaster) { broadcaster }
   end
 
   describe '#initialize' do
-    its(:mode) { should be :recipient }
-    its(:host) { should eq host }
-    its(:port) { should eq port }
-
-    it 'raises on invalid mode' do
-      expect do
-        described_class.new(port, :foo)
-      end.to raise_error ArgumentError
-    end
-
     it 'raises on omitted target' do
       expect do
         described_class.new(nil, :recipient)
@@ -50,21 +44,14 @@ describe Listen::TCP::Listener do
   context 'when broadcaster' do
     subject { described_class.new(port, :broadcaster) }
 
-    it { should be_a_broadcaster }
-    it { should_not be_a_recipient }
-
     it 'does not force TCP adapter through options' do
       expect(subject.options).not_to include(force_tcp: true)
     end
 
-    context 'when host is omitted' do
-      its(:host) { should be_nil }
-    end
-
     describe '#start' do
       before do
-        adapter.stub_chain(:async, :start)
-        broadcaster.stub(:start)
+        allow(subject).to receive(:_start_adapter)
+        allow(broadcaster).to receive(:start)
       end
 
       it 'registers broadcaster' do
@@ -79,49 +66,27 @@ describe Listen::TCP::Listener do
       end
     end
 
-    describe '#block' do
-      let(:async) { double('TCP broadcaster async', broadcast: true) }
-      let(:callback) { double(call: true) }
-      let(:changes) do
-        { modified: ['/foo'], added: [], removed: [] }
-      end
-
+    describe 'queue' do
       before do
-        broadcaster.stub(:async).and_return async
-      end
-
-      after do
-        subject.block.call changes.values
-      end
-
-      context 'when paused' do
-        it 'honours paused state and does nothing' do
-          subject.pause
-          expect(broadcaster).not_to receive(:async)
-          expect(callback).not_to receive(:call)
-        end
+        allow(broadcaster).to receive(:async).and_return async
       end
 
       context 'when stopped' do
         it 'honours stopped state and does nothing' do
           allow(subject).to receive(:supervisor) do
-            double('SupervisionGroup', terminate: true)
+            instance_double(Celluloid::SupervisionGroup, terminate: true)
           end
 
           subject.stop
+          subject.queue(:file, :modified, 'foo')
           expect(broadcaster).not_to receive(:async)
-          expect(callback).not_to receive(:call)
         end
       end
 
       it 'broadcasts changes asynchronously' do
-        message = Listen::TCP::Message.new changes
+        message = Listen::TCP::Message.new(:file, :modified, 'foo', {})
         expect(async).to receive(:broadcast).with message.payload
-      end
-
-      it 'invokes original callback block' do
-        subject.block = callback
-        expect(callback).to receive(:call).with(*changes.values)
+        subject.queue(:file, :modified, 'foo')
       end
     end
   end
@@ -132,13 +97,5 @@ describe Listen::TCP::Listener do
     it 'forces TCP adapter through options' do
       expect(subject.options).to include(force_tcp: true)
     end
-
-    it { should_not be_a_broadcaster }
-    it { should be_a_recipient }
-
-    context 'when host is omitted' do
-      its(:host) { should eq described_class::DEFAULT_HOST }
-    end
   end
-
 end

data/spec/lib/listen/tcp/message_spec.rb

@@ -11,31 +11,65 @@ describe Listen::TCP::Message do
 
   describe '#initialize' do
     it 'initializes with an object' do
-      message = described_class.new(object)
-      expect(message.object).to be object
+      message = described_class.new(1, 2, 3)
+      expect(message.object).to eq [1, 2, 3]
     end
   end
 
   describe '#object=' do
-    before do
-      subject.object = object
+    subject do
+      described_class.new(object).tap do |message|
+        message.object = object
+      end
+    end
+
+    describe '#object' do
+      subject { super().object }
+      it  { is_expected.to be object }
+    end
+
+    describe '#body' do
+      subject { super().body }
+      it { is_expected.to eq body }
+    end
+
+    describe '#size' do
+      subject { super().size }
+      it { is_expected.to eq size }
     end
 
-    its(:object)  { should be object }
-    its(:body)    { should eq body }
-    its(:size)    { should eq size }
-    its(:payload) { should eq payload }
+    describe '#payload' do
+      subject { super().payload }
+      it { is_expected.to eq payload }
+    end
   end
 
   describe '#payload=' do
-    before do
-      subject.payload = payload
+    subject do
+      described_class.new(object).tap do |message|
+        message.payload = payload
+      end
+    end
+
+    describe '#object' do
+      subject { super().object }
+      it { is_expected.to eq object }
+    end
+
+    describe '#body' do
+      subject { super().body }
+      it { is_expected.to eq body }
+    end
+
+    describe '#size' do
+      subject { super().size }
+      it { is_expected.to eq size }
     end
 
-    its(:object)  { should eq object }
-    its(:body)    { should eq body }
-    its(:size)    { should eq size }
-    its(:payload) { should be payload }
+    describe '#payload' do
+      subject { super().payload }
+      it { is_expected.to be payload }
+    end
   end
 
   describe '.from_buffer' do

data/spec/lib/listen_spec.rb

@@ -9,7 +9,7 @@ describe Listen do
 
     context 'when using :forward_to option' do
       it 'initializes TCP-listener in broadcast-mode' do
-        expect(Listen::TCP::Listener).to receive(:new).
+        expect(Listen::Listener).to receive(:new).
           with(4000, :broadcaster, '/path', {})
         described_class.to('/path', forward_to: 4000)
       end
@@ -18,7 +18,7 @@ describe Listen do
     it 'sets stopping at false' do
       allow(Listen::Listener).to receive(:new)
       Listen.to('/path')
-      expect(Listen.stopping).to be_false
+      expect(Listen.stopping).to be_falsey
     end
   end
 
@@ -41,7 +41,7 @@ describe Listen do
 
   describe '.on' do
     it 'initializes TCP-listener in recipient-mode' do
-      expect(Listen::TCP::Listener).to receive(:new).
+      expect(Listen::Listener).to receive(:new).
         with(4000, :recipient, '/path')
       described_class.on(4000, '/path')
     end

data/spec/spec_helper.rb

@@ -16,15 +16,18 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.color_enabled = true
   config.order = :random
   config.filter_run focus: true
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
-  config.fail_fast = !ci?
+  # config.fail_fast = !ci?
   config.expect_with :rspec do |c|
     c.syntax = :expect
   end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_doubled_constant_names = true
+    mocks.verify_partial_doubles = true
+  end
 end
 
 require 'rspec/retry'

data/spec/support/acceptance_helper.rb

@@ -1,47 +1,266 @@
-def listen(lag = 0.5)
-  sleep lag # wait for changes
-  sleep_until_next_second
-  reset_changes
-  yield
-  sleep lag # wait for changes
-  @changes
-end
+{
+  modification: :modified,
+  addition: :added,
+  removal: :removed,
+  queued_modification: :modified,
+  queued_addition: :added,
+}.each do |description, type|
 
-def setup_listener(options, callback)
-  reset_changes
-  Listen.to(paths, options, &callback)
-end
+  RSpec::Matchers.define "process_#{description}_of".to_sym do |expected|
+    match do |actual|
+      # Use cases:
+      # 1. reset the changes so they don't have leftovers
+      # 2. keep the queue if we're testing for existing accumulated changes
 
-def reset_changes
-  @changes = { modified: [], added: [], removed: [] }
-end
+      # if were testing the queue (e.g. after unpause), don't reset
+      check_already_queued = /queued_/ =~ description
+      reset_queue = !check_already_queued
+
+      actual.listen(reset_queue) do
+        change_fs(type, expected) unless check_already_queued
+      end
+      actual.changes[type].include? expected
+    end
 
-def add_changes(type, changes)
-  @changes[type] += relative_path(changes)
-  @changes[type].uniq!
-  @changes[type].sort!
+    failure_message do |actual|
+      result = actual.changes.inspect
+      "expected #{result} to include #{description} of #{expected}"
+    end
+
+    failure_message_when_negated do |actual|
+      result = actual.changes.inspect
+      "expected #{result} to not include #{description} of #{expected}"
+    end
+  end
 end
 
-def relative_path(changes)
-  changes.map do |change|
-    unfrozen_copy = change.dup
-    [paths].flatten.each { |path| unfrozen_copy.gsub!(/#{path.to_s}\//, '') }
-    unfrozen_copy
+def change_fs(type, path)
+  case type
+  when :modified
+    unless File.exist?(path)
+      fail "Bad test: cannot modify #{path.inspect} (it doesn't exist)"
+    end
+
+    # wait until full second, because this might be followed by a modification
+    # event (which otherwise may not be detected every time)
+    _sleep_until_next_second(Pathname.pwd)
+
+    open(path, 'a') { |f| f.write('foo') }
+
+    # separate it from upcoming modifications"
+    _sleep_to_separate_events
+  when :added
+    if File.exist?(path)
+      fail "Bad test: cannot add #{path.inspect} (it already exists)"
+    end
+
+    # wait until full second, because this might be followed by a modification
+    # event (which otherwise may not be detected every time)
+    _sleep_until_next_second(Pathname.pwd)
+
+    open(path, 'w') { |f| f.write('foo') }
+
+    # separate it from upcoming modifications"
+    _sleep_to_separate_events
+  when :removed
+    unless File.exist?(path)
+      fail "Bad test: cannot remove #{path.inspect} (it doesn't exist)"
+    end
+    File.unlink(path)
+  else
+    fail "bad test: unknown type: #{type.inspect}"
   end
 end
 
-# Generates a small time difference before performing a time sensitive
-# task (like comparing mtimes of files).
+# Used by change_fs() above so that the FS change (e.g. file created) happens
+# as close to the start of a new second (time) as possible.
 #
-# @note Modification time for files only includes the milliseconds on Linux
-#   with MRI > 1.9.2 and platform that support it (OS X 10.8 not included),
-#   that's why we generate a difference that's greater than 1 second.
+# E.g. if file is created at 1234567.999 (unix time), it's mtime on some
+# filesystems is rounded, so it becomes 1234567.0, but if the change
+# notification happens a little while later, e.g. at 1234568.111, now the file
+# mtime and the current time in seconds are different (1234567 vs 1234568), and
+# so the MD5 test won't kick in (see file.rb) - the file will not be considered
+# for content checking (md5), so File.change will consider the file unmodified.
 #
-def sleep_until_next_second
-  return unless darwin?
+# This means, that if a file is added at 1234567.888 (and updated in Record),
+# and then its content is modified at 1234567.999, and checking for changes
+# happens at 1234568.111, the modification won't be detected.
+# (because Record mtime is 1234567.0, current FS mtime from stat() is the
+# same, and the checking happens in another second - 1234568).
+#
+# So basically, adding a file and detecting its later modification should all
+# happen within 1 second (which makes testing and debugging difficult).
+#
+def _sleep_until_next_second(path)
+  Listen::File.inaccurate_mac_time?(path)
 
   t = Time.now
   diff = t.to_f - t.to_i
 
   sleep(1.05 - diff)
 end
+
+# Special class to only allow changes within a specific time window
+
+class TimedChanges
+  attr_reader :changes
+
+  def initialize
+    # Set to non-nil, because changes can immediately come after unpausing
+    # listener in an Rspec 'before()' block
+    @changes = { modified: [], added: [], removed: [] }
+  end
+
+  def change_offset
+    Time.now.to_f - @yield_time
+  end
+
+  def freeze_offset
+    result = @freeze_time - @yield_time
+    # Make an "almost zero" value more readable
+    result < 1e-4 ? 1e-4 : result
+  end
+
+  # Allow changes only during specific time wine
+  def allow_changes(reset_queue = true)
+    @freeze_time = nil
+    if reset_queue
+      # Clear to prepare for collecting new FS events
+      @changes = { modified: [], added: [], removed: [] }
+    else
+      # Since we're testing the queue and the listener callback is adding
+      # changes to the same hash (e.g. after a pause), copy the existing data
+      # to a new, unfrozen hash
+      @changes = @changes.dup if @changes.frozen?
+      @changes ||= { modified: [], added: [], removed: [] }
+    end
+
+    @yield_time = Time.now.to_f
+    yield
+    # Prevent recording changes after timeout
+    @changes.freeze
+    @freeze_time = Time.now.to_f
+  end
+end
+
+# Conveniently wrap a Listener instance for testing
+class ListenerWrapper
+  attr_reader :listener, :changes
+  attr_accessor :lag
+
+  def initialize(callback, paths, *args)
+    # Lag depends mostly on wait_for_delay On Linux desktop, it's 0.06 - 0.11
+    #
+    # On Travis it used to be > 0.5, but that was before broadcaster sent
+    # changes immediately, so 0.2-0.4 might be enough for Travis, but we set it
+    # to 0.6
+    #
+    # The value should be 2-3 x wait_for_delay + time between fs operation and
+    # notification, which for polling and FSEvent means the configured latency
+    @lag = 0.6
+
+    @paths = paths
+
+    # Isolate collected changes between tests/listener instances
+    @timed_changes = TimedChanges.new
+
+    if callback
+      @listener = Listen.send(*args) do  |modified, added, removed|
+        # Add changes to trigger frozen Hash error, making sure lag is enough
+        _add_changes(:modified, modified, changes)
+        _add_changes(:added, added, changes)
+        _add_changes(:removed, removed, changes)
+
+        unless callback == :track_changes
+          callback.call(modified, added, removed)
+        end
+      end
+    else
+      @listener = Listen.send(*args)
+    end
+  end
+
+  def changes
+    @timed_changes.changes
+  end
+
+  def listen(reset_queue = true)
+    @timed_changes.allow_changes(reset_queue) do
+
+      # give events time to be received, queued and processed
+      sleep lag
+
+      yield
+
+      sleep lag # wait for changes
+    end
+
+    # Keep this to detect a lag too small (changes during this sleep
+    # will trigger "frozen hash" error caught below (and displaying timeout
+    # details)
+    sleep 1
+
+    changes
+  end
+
+  private
+
+  def _add_changes(type, changes, dst)
+    dst[type] += _relative_path(changes)
+    dst[type].uniq!
+    dst[type].sort!
+
+  rescue RuntimeError => e
+    raise unless e.message == "can't modify frozen Hash"
+
+    # Show how by much the changes missed the timeout
+    change_offset = @timed_changes.change_offset
+    freeze_offset = @timed_changes.freeze_offset
+
+    msg = "Changes took #{change_offset}s (allowed lag: #{freeze_offset})s"
+
+    # Use STDERR (workaround for Celluloid, since it catches abort)
+    STDERR.puts msg
+    abort(msg)
+  end
+
+  def _relative_path(changes)
+    changes.map do |change|
+      unfrozen_copy = change.dup
+      [@paths].flatten.each do |path|
+        sub = path.sub(/\/$/, '').to_s
+        unfrozen_copy.gsub!(/^#{sub}\//, '')
+      end
+      unfrozen_copy
+    end
+  end
+end
+
+def setup_listener(options, callback = nil)
+  ListenerWrapper.new(callback, paths, :to, paths, options)
+end
+
+def setup_recipient(port, callback = nil)
+  ListenerWrapper.new(callback, paths, :on, port)
+end
+
+def _sleep_to_separate_events
+  # separate the events or Darwin and Polling
+  # will detect only the :added event
+  #
+  # (This is because both use directory scanning
+  # through Celluloid tasks, which may not kick in
+  # time before the next filesystem change)
+  #
+  # The minimum for this is the time it takes between a syscall
+  # changing the filesystem ... and ... an async
+  # Listen::File.scan to finish comparing the file with the
+  # Record
+  #
+  # This necessary for:
+  # - Darwin Adapter
+  # - Polling Adapter
+  # - Linux Adapter in FSEvent emulation mode
+  # - maybe Windows adapter (probably not)
+  sleep 0.4
+end