listen 2.7.5 → 2.7.6

data/spec/acceptance/tcp_spec.rb

@@ -1,145 +1,136 @@
 require 'spec_helper'
 
-describe Listen::TCP do
+describe Listen::Listener do
 
   let(:port) { 4000 }
-
-  let(:broadcaster) { Listen.to(Dir.pwd, forward_to: port) }
-  let(:recipient)  { Listen.on(port) }
-  let(:callback) do
-    lambda do |modified, added, removed|
-      add_changes(:modified, modified)
-      add_changes(:added, added)
-      add_changes(:removed, removed)
-    end
-  end
+  let(:broadcast_options) { { forward_to: port } }
   let(:paths) { Pathname.new(Dir.pwd) }
 
   around { |example| fixtures { example.run } }
 
-  before do
-    broadcaster.start
-  end
-
-  context 'when broadcaster' do
-    before do
-      broadcaster.block = callback
-    end
-
-    it 'still handles local changes' do
-      expect(listen do
-        touch 'file.rb'
-      end).to eq(
-        modified: [],
-        added:    ['file.rb'],
-        removed:  []
-      )
-    end
-
-    it 'may be paused and unpaused' do
-      broadcaster.pause
-
-      expect(listen do
-        touch 'file.rb'
-      end).to eq(
-        modified: [],
-        added:    [],
-        removed:  []
-      )
-
-      broadcaster.unpause
-
-      expect(listen do
-        touch 'file.rb'
-      end).to eq(
-        modified: ['file.rb'],
-        added:    [],
-        removed:  []
-      )
-    end
-
-    it 'may be stopped and restarted' do
-      broadcaster.stop
-
-      expect(listen do
-        touch 'file.rb'
-      end).to eq(
-        modified: [],
-        added:    [],
-        removed:  []
-      )
-
-      broadcaster.start
-
-      expect(listen do
-        touch 'file.rb'
-      end).to eq(
-        modified: ['file.rb'],
-        added:    [],
-        removed:  []
-      )
+  modes = if !windows? || Celluloid::VERSION > '0.15.2'
+            [:recipient, :broadcaster]
+          else
+            [:broadcaster]
+          end
+
+  modes.each do |mode|
+    context "when #{mode}" do
+      if mode == :broadcaster
+        subject { setup_listener(broadcast_options, :track_changes) }
+        before { subject.listener.start }
+        after { subject.listener.stop }
+      else
+        subject { setup_recipient(port, :track_changes) }
+        let(:broadcaster) { setup_listener(broadcast_options) }
+
+        before do
+          broadcaster.listener.start
+          # Travis on OSX is too slow
+          subject.lag = 1.2
+          subject.listener.start
+        end
+        after do
+          broadcaster.listener.stop
+          subject.listener.stop
+        end
+      end
+
+      it { should process_addition_of('file.rb') }
+
+      context 'when paused' do
+        before { subject.listener.pause }
+
+        context 'with no queued changes' do
+          it { should_not process_addition_of('file.rb') }
+
+          context 'when unpaused' do
+            before { subject.listener.unpause }
+            it { should process_addition_of('file.rb') }
+          end
+        end
+
+        context 'with queued addition' do
+          before { change_fs(:added, 'file.rb') }
+          it { should_not process_modification_of('file.rb') }
+
+          context 'when unpaused' do
+            before { subject.listener.unpause }
+            it { should process_queued_addition_of('file.rb') }
+            it { should process_modification_of('file.rb') }
+          end
+        end
+
+        context 'with queued modification' do
+          before do
+            change_fs(:added, 'file.rb')
+            change_fs(:modified, 'file.rb')
+          end
+
+          it { should_not process_queued_addition_of('file.rb') }
+          it { should_not process_queued_modification_of('file.rb') }
+
+          context 'when unpaused' do
+            before { subject.listener.unpause }
+            it { should process_queued_addition_of('file.rb') }
+
+            # NOTE: when adapter is 'local_fs?', the change optimizer
+            # (_squash_changes) reduces the "add+mod" into a single "add"
+            if mode == :broadcaster
+              # "optimizing" on local fs (broadcaster) will remove
+              # :modified from queue
+              it { should_not process_queued_modification_of('file.rb') }
+            else
+              # optimization skipped, because it's TCP, so we'll have both
+              # :modified and :added events for same file
+              it { should process_queued_modification_of('file.rb') }
+            end
+
+            it { should process_modification_of('file.rb') }
+          end
+        end
+      end
+
+      context 'when stopped' do
+        before { subject.listener.stop }
+
+        context 'with no queued changes' do
+          it { should_not process_addition_of('file.rb') }
+
+          context 'when started' do
+            before { subject.listener.start }
+            it { should process_addition_of('file.rb') }
+          end
+        end
+
+        context 'with queued addition' do
+          before { change_fs(:added, 'file.rb') }
+          it { should_not process_modification_of('file.rb') }
+
+          context 'when started' do
+            before { subject.listener.start }
+            it { should_not process_queued_addition_of('file.rb') }
+            it { should process_modification_of('file.rb') }
+          end
+        end
+
+        context 'with queued modification' do
+          before do
+            change_fs(:added, 'file.rb')
+            change_fs(:modified, 'file.rb')
+          end
+
+          it { should_not process_queued_addition_of('file.rb') }
+          it { should_not process_queued_modification_of('file.rb') }
+
+          context 'when started' do
+            before { subject.listener.start }
+            it { should_not process_queued_addition_of('file.rb') }
+            it { should_not process_queued_modification_of('file.rb') }
+            it { should process_modification_of('file.rb') }
+          end
+        end
+      end
     end
   end
-
-  context 'when recipient' do
-    before do
-      recipient.start
-      recipient.block = callback
-    end
-
-    it 'receives changes over TCP' do
-      expect(listen(1) do
-        touch 'file.rb'
-      end).to eq(
-        modified: [],
-        added:    ['file.rb'],
-        removed:  []
-      )
-    end
-
-    it 'may be paused and unpaused' do
-      recipient.pause
-
-      expect(listen(1) do
-        touch 'file.rb'
-      end).to eq(
-        modified: [],
-        added:    [],
-        removed:  []
-      )
-
-      recipient.unpause
-
-      expect(listen(1) do
-        touch 'file.rb'
-      end).to eq(
-        modified: ['file.rb'],
-        added:    [],
-        removed:  []
-      )
-    end
-
-    it 'may be stopped and restarted' do
-      recipient.stop
-
-      expect(listen(1) do
-        touch 'file.rb'
-      end).to eq(
-        modified: [],
-        added:    [],
-        removed:  []
-      )
-
-      recipient.start
-
-      expect(listen(1) do
-        touch 'file.rb'
-      end).to eq(
-        modified: ['file.rb'],
-        added:    [],
-        removed:  []
-      )
-    end
-  end
-
 end

data/spec/lib/listen/adapter/base_spec.rb

@@ -1,46 +1,29 @@
 require 'spec_helper'
 
 describe Listen::Adapter::Base do
-  let(:adapter) { described_class.new(listener) }
-  let(:registry) { double(Celluloid::Registry) }
-  let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
+  subject { described_class.new(listener) }
 
-  describe '#_latency' do
-    it 'returns default_latency with listener actor latency not present' do
-      latency = Listen::Adapter::Base::DEFAULT_LATENCY
-      expect(adapter.send(:_latency)).to eq latency
-    end
+  let(:listener) { instance_double(Listen::Listener) }
 
-    it 'returns latency from listener actor if present' do
-      listener.stub(:options) { { latency: 1234 } }
-      expect(adapter.send(:_latency)).to eq 1234
-    end
-  end
+  before { allow(listener).to receive(:async).with(:change_pool) { worker } }
 
   describe '#_notify_change' do
-    let(:change_pool) { double(Listen::Change) }
-    let(:change_pool_async) { double('ChangePoolAsync') }
-    before do
-      change_pool.stub(:async) { change_pool_async }
-      registry.stub(:[]).with(:change_pool) { change_pool }
-    end
-
-    context 'listener listen' do
-      before { listener.stub(:listen?) { true } }
+    context 'listener is listening or paused' do
+      let(:worker) { instance_double(Listen::Change) }
 
       it 'calls change on change_pool asynchronously' do
-        expect(change_pool_async).to receive(:change).
-          with('path', type: 'Dir', recurcise: true)
-        adapter.send(:_notify_change, 'path', type: 'Dir', recurcise: true)
+        expect(worker).to receive(:change).
+          with(:dir, 'path', recursive: true)
+        subject.send(:_notify_change, :dir, 'path', recursive: true)
       end
     end
 
-    context "listener doesn't listen" do
-      before { listener.stub(:listen?) { false } }
+    context 'listener is stopped' do
+      let(:worker) { nil }
 
-      it 'calls change on change_pool asynchronously' do
-        expect(change_pool_async).to_not receive(:change)
-        adapter.send(:_notify_change, 'path', type: 'Dir', recurcise: true)
+      it 'does not fail when no worker is available' do
+        expect(worker).to_not receive(:change)
+        subject.send(:_notify_change, :dir, 'path', recursive: true)
       end
     end
   end

data/spec/lib/listen/adapter/bsd_spec.rb

@@ -1,42 +1,14 @@
 require 'spec_helper'
 
 describe Listen::Adapter::BSD do
+  describe 'class' do
+    subject { described_class }
+    it { should be_local_fs }
 
-  if bsd?
-    let(:listener) { double(Listen::Listener) }
-    let(:adapter) { described_class.new(listener) }
-
-    describe '.usable?' do
-      it 'returns always true' do
-        expect(described_class).to be_usable
-      end
-
-      it 'requires rb-kqueue and find gem' do
-        described_class.usable?
-        expect(defined?(KQueue)).to be_true
-        expect(defined?(Find)).to be_true
-      end
+    if bsd?
+      it { should be_usable }
+    else
+      it { should_not be_usable }
     end
   end
-
-  if darwin?
-    it "isn't usable on Darwin" do
-      expect(described_class).to_not be_usable
-    end
-  end
-
-  if linux?
-    it "isn't usable on Linux" do
-      expect(described_class).to_not be_usable
-    end
-  end
-
-  if windows?
-    it "isn't usable on Windows" do
-      expect(described_class).to_not be_usable
-    end
-  end
-
-  specify { expect(described_class).to be_local_fs }
-
 end

data/spec/lib/listen/adapter/darwin_spec.rb

@@ -1,42 +1,30 @@
 require 'spec_helper'
 
 describe Listen::Adapter::Darwin do
-  if darwin?
-    let(:listener) { double(Listen::Listener) }
-    let(:adapter) { described_class.new(listener) }
-
-    describe '.usable?' do
-      it 'returns always true' do
-        expect(described_class).to be_usable
-      end
-    end
-
-    describe '#initialize' do
-      it 'requires rb-fsevent gem' do
-        described_class.new(listener)
-        expect(defined?(FSEvent)).to be_true
-      end
+  describe 'class' do
+    subject { described_class }
+    it { should be_local_fs }
+
+    if darwin?
+      it { should be_usable }
+    else
+      it { should_not be_usable }
     end
   end
 
-  if windows?
-    it "isn't usable on Windows" do
-      expect(described_class).to_not be_usable
-    end
-  end
+  let(:options) { {} }
+  let(:listener) { instance_double(Listen::Listener, options: options) }
 
-  if linux?
-    it "isn't usable on Linux" do
-      expect(described_class).to_not be_usable
+  describe '#_latency' do
+    subject { described_class.new(listener).send(:_latency) }
+
+    context 'with no overriding option' do
+      it { should eq described_class.const_get('DEFAULT_LATENCY') }
     end
-  end
 
-  if bsd?
-    it "isn't usable on BSD" do
-      expect(described_class).to_not be_usable
+    context 'with custom latency overriding' do
+      let(:options) { { latency: 1234 } }
+      it { should eq 1234 }
     end
   end
-
-  specify { expect(described_class).to be_local_fs }
-
 end

data/spec/lib/listen/adapter/linux_spec.rb

@@ -1,19 +1,27 @@
 require 'spec_helper'
 
 describe Listen::Adapter::Linux do
+  describe 'class' do
+    subject { described_class }
+    it { should be_local_fs }
+
+    if linux?
+      it { should be_usable }
+    else
+      it { should_not be_usable }
+    end
+  end
+
   if linux?
-    let(:listener) { double(Listen::Listener) }
+    let(:listener) { instance_double(Listen::Listener) }
     let(:adapter) { described_class.new(listener) }
 
-    describe '.usable?' do
-      it 'returns always true' do
-        expect(described_class).to be_usable
-      end
-    end
-
     describe '#initialize' do
+      before do
+        allow(listener).to receive(:directories) { [] }
+      end
       it 'requires rb-inotify gem' do
-        described_class.new(listener)
+        adapter.send(:_configure)
         expect(defined?(INotify)).to be
       end
     end
@@ -23,13 +31,16 @@ describe Listen::Adapter::Linux do
       let!(:adapter) { described_class.new(listener) }
 
       before do
-        allow_any_instance_of(INotify::Notifier).to receive(:watch).
-          and_raise(Errno::ENOSPC)
-
+        require 'rb-inotify'
         allow(listener).to receive(:directories) { ['foo/dir'] }
+        fake_worker = double(:fake_worker)
+        allow(fake_worker).to receive(:watch).and_raise(Errno::ENOSPC)
+
+        fake_notifier = double(:fake_notifier, new: fake_worker)
+        stub_const('INotify::Notifier', fake_notifier)
       end
 
-      it 'should be show before calling abort' do
+      it 'should be shown before calling abort' do
         expected_message = described_class.const_get('INOTIFY_LIMIT_MESSAGE')
         expect(STDERR).to receive(:puts).with(expected_message)
 
@@ -40,15 +51,18 @@ describe Listen::Adapter::Linux do
       end
     end
 
-    describe '_worker_callback' do
+    describe '_callback' do
+      before do
+        allow(listener).to receive(:directories) { [] }
+      end
 
       let(:expect_change) do
         lambda do |change|
           allow_any_instance_of(Listen::Adapter::Base).
             to receive(:_notify_change).
             with(
+              :file,
               Pathname.new('path/foo.txt'),
-              type: 'File',
               change: change,
               cookie: 123)
         end
@@ -56,53 +70,33 @@ describe Listen::Adapter::Linux do
 
       let(:event_callback) do
         lambda do |flags|
-          callback = adapter.send(:_worker_callback)
-          callback.call double(:event,
-                               name: 'foo.txt',
-                               flags: flags,
-                               absolute_name: 'path/foo.txt',
-                               cookie: 123)
+          callback = adapter.send(:_callback)
+          callback.call double(
+            :inotify_event,
+            name: 'foo.txt',
+            watcher: double(:watcher, path: 'path'),
+            flags: flags,
+            cookie: 123)
         end
       end
 
-      # use case: close_write is the only way to detect changes
-      # on ecryptfs
-      it 'recognizes close_write as modify' do
-        expect_change.call(:modified)
-        event_callback.call([:close_write])
-      end
+      # TODO: get fsevent adapter working like INotify
+      unless /1|true/ =~ ENV['LISTEN_GEM_SIMULATE_FSEVENT']
+        it 'recognizes close_write as modify' do
+          expect_change.call(:modified)
+          event_callback.call([:close_write])
+        end
 
-      it 'recognizes moved_to as moved_to' do
-        expect_change.call(:moved_to)
-        event_callback.call([:moved_to])
-      end
+        it 'recognizes moved_to as moved_to' do
+          expect_change.call(:moved_to)
+          event_callback.call([:moved_to])
+        end
 
-      it 'recognizes moved_from as moved_from' do
-        expect_change.call(:moved_from)
-        event_callback.call([:moved_from])
+        it 'recognizes moved_from as moved_from' do
+          expect_change.call(:moved_from)
+          event_callback.call([:moved_from])
+        end
       end
     end
-
-  end
-
-  if darwin?
-    it "isn't usable on Darwin" do
-      expect(described_class).to_not be_usable
-    end
-  end
-
-  if windows?
-    it "isn't usable on Windows" do
-      expect(described_class).to_not be_usable
-    end
   end
-
-  if bsd?
-    it "isn't usable on BSD" do
-      expect(described_class).to_not be_usable
-    end
-  end
-
-  specify { expect(described_class).to be_local_fs }
-
 end