nanoc 4.7.0 → 4.7.1

data/spec/nanoc/base/errors/dependency_cycle_spec.rb

@@ -0,0 +1,32 @@
+describe Nanoc::Int::Errors::DependencyCycle do
+  subject(:error) { described_class.new(graph) }
+
+  let(:graph) do
+    Nanoc::Int::DirectedGraph.new([]).tap do |g|
+      g.add_edge(rep_a, rep_b)
+      g.add_edge(rep_b, rep_c)
+      g.add_edge(rep_c, rep_d)
+      g.add_edge(rep_d, rep_e)
+      g.add_edge(rep_e, rep_b)
+    end
+  end
+
+  let(:rep_a) { Nanoc::Int::ItemRep.new(Nanoc::Int::Item.new('a', {}, '/a.md'), :default) }
+  let(:rep_b) { Nanoc::Int::ItemRep.new(Nanoc::Int::Item.new('b', {}, '/b.md'), :default) }
+  let(:rep_c) { Nanoc::Int::ItemRep.new(Nanoc::Int::Item.new('c', {}, '/c.md'), :default) }
+  let(:rep_d) { Nanoc::Int::ItemRep.new(Nanoc::Int::Item.new('d', {}, '/d.md'), :default) }
+  let(:rep_e) { Nanoc::Int::ItemRep.new(Nanoc::Int::Item.new('e', {}, '/e.md'), :default) }
+
+  it 'has an informative error message' do
+    expected = <<EOS
+The site cannot be compiled because there is a dependency cycle:
+
+    (1) item /b.md, rep :default, depends on
+    (2) item /c.md, rep :default, depends on
+    (3) item /d.md, rep :default, depends on
+    (4) item /e.md, rep :default, depends on (1)
+EOS
+
+    expect(error.message).to eql(expected)
+  end
+end

data/spec/nanoc/base/filter_spec.rb

@@ -37,6 +37,42 @@ describe Nanoc::Filter do
     end
   end
 
+  describe '.always_outdated? + .always_outdated' do
+    context 'not always outdated' do
+      let(:filter_class) do
+        Class.new(Nanoc::Filter) do
+          identifier :bea22a356b6b031cea1e615087179803818c6a53
+
+          def run(content, _params)
+            content.upcase
+          end
+        end
+      end
+
+      it 'is not always outdated' do
+        expect(filter_class).not_to be_always_outdated
+      end
+    end
+
+    context 'always outdated' do
+      let(:filter_class) do
+        Class.new(Nanoc::Filter) do
+          identifier :d7413fa71223e5e69b03a0abfa25806e07e14f3a
+
+          always_outdated
+
+          def run(content, _params)
+            content.upcase
+          end
+        end
+      end
+
+      it 'is always outdated' do
+        expect(filter_class).to be_always_outdated
+      end
+    end
+  end
+
   describe '#depend_on' do
     subject { filter.depend_on(item_views) }
 

data/spec/nanoc/base/services/compiler/phases/abstract_spec.rb

@@ -1,6 +1,6 @@
 describe Nanoc::Int::Compiler::Phases::Abstract do
   subject(:phase) do
-    described_class.new(wrapped: wrapped, name: 'my_phase')
+    described_class.new(wrapped: wrapped)
   end
 
   let(:item) { Nanoc::Int::Item.new('foo', {}, '/stuff.md') }
@@ -19,29 +19,41 @@ describe Nanoc::Int::Compiler::Phases::Abstract do
   describe '#call' do
     subject { phase.call(rep, is_outdated: false) }
 
-    let(:phase) do
+    let(:phase_class) do
       Class.new(described_class) do
+        def self.to_s
+          'AbstractSpec::MyTestingPhaseClass'
+        end
+
         def run(_rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument
           yield
         end
-      end.new(wrapped: wrapped, name: 'my_phase')
+      end
     end
 
-    let(:wrapped) do
+    let(:phase) { phase_class.new(wrapped: wrapped) }
+
+    let(:wrapped_class) do
       Class.new(described_class) do
+        def self.to_s
+          'AbstractSpec::MyTestingWrappedPhaseClass'
+        end
+
         def run(_rep, is_outdated:); end
-      end.new(wrapped: nil, name: 'wrapped_phase')
+      end
     end
 
+    let(:wrapped) { wrapped_class.new(wrapped: nil) }
+
     it 'sends the proper notifications' do
-      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_started, 'my_phase', rep).ordered
-      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_yielded, 'my_phase', rep).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_started, 'MyTestingPhaseClass', rep).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_yielded, 'MyTestingPhaseClass', rep).ordered
 
-      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_started, 'wrapped_phase', rep).ordered
-      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_ended, 'wrapped_phase', rep).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_started, 'MyTestingWrappedPhaseClass', rep).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_ended, 'MyTestingWrappedPhaseClass', rep).ordered
 
-      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_resumed, 'my_phase', rep).ordered
-      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_ended, 'my_phase', rep).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_resumed, 'MyTestingPhaseClass', rep).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_ended, 'MyTestingPhaseClass', rep).ordered
 
       subject
     end

data/spec/nanoc/base/services/outdatedness_rules_spec.rb

@@ -435,5 +435,46 @@ describe Nanoc::Int::OutdatednessRules do
 
       # …
     end
+
+    describe 'UsesAlwaysOutdatedFilter' do
+      let(:rule_class) { Nanoc::Int::OutdatednessRules::UsesAlwaysOutdatedFilter }
+
+      before do
+        allow(action_provider).to receive(:memory_for).with(item_rep).and_return(mem)
+      end
+
+      context 'unknown filter' do
+        let(:mem) do
+          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+            mem.add_snapshot(:donkey, '/foo.md')
+            mem.add_filter(:asdf, {})
+          end
+        end
+
+        it { is_expected.not_to be }
+      end
+
+      context 'known filter, not always outdated' do
+        let(:mem) do
+          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+            mem.add_snapshot(:donkey, '/foo.md')
+            mem.add_filter(:erb, {})
+          end
+        end
+
+        it { is_expected.not_to be }
+      end
+
+      context 'known filter, always outdated' do
+        let(:mem) do
+          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+            mem.add_snapshot(:donkey, '/foo.md')
+            mem.add_filter(:xsl, {})
+          end
+        end
+
+        it { is_expected.to be }
+      end
+    end
   end
 end

data/spec/nanoc/cli/commands/compile/file_action_printer_spec.rb

@@ -1,4 +1,4 @@
-describe Nanoc::CLI::Commands::Compile::FileActionPrinter, stdio: true do
+describe Nanoc::CLI::Commands::CompileListeners::FileActionPrinter, stdio: true do
   let(:listener) { described_class.new(reps: reps) }
 
   before { Timecop.freeze(Time.local(2008, 1, 2, 14, 5, 0)) }

data/spec/nanoc/cli/commands/compile/timing_recorder_spec.rb

@@ -1,4 +1,4 @@
-describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
+describe Nanoc::CLI::Commands::CompileListeners::TimingRecorder, stdio: true do
   let(:listener) { described_class.new(reps: reps) }
 
   before { Timecop.freeze(Time.local(2008, 1, 2, 14, 5, 0)) }
@@ -6,6 +6,9 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
 
   before { Nanoc::CLI.verbosity = 2 }
 
+  before { listener.start }
+  after { listener.stop_safely }
+
   let(:reps) do
     Nanoc::Int::ItemRepRepo.new.tap do |reps|
       reps << rep
@@ -20,53 +23,57 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     end
   end
 
-  it 'records single from filtering_started to filtering_ended' do
-    listener.start
+  let(:other_rep) do
+    Nanoc::Int::ItemRep.new(item, :other).tap do |rep|
+      rep.raw_paths = { default: ['/bye.html'] }
+    end
+  end
 
+  it 'prints filters table' do
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
     Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
     Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 14, 1))
+    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 14, 3))
+    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
 
     expect { listener.stop }
-      .to output(/^\s*erb │     1   1\.00s   1\.00s   1\.00s   1\.00s$/).to_stdout
+      .to output(/^\s*erb │     2   1\.00s   1\.50s   1\.90s   1\.95s   2\.00s   3\.00s$/).to_stdout
   end
 
-  it 'records multiple from filtering_started to filtering_ended' do
-    listener.start
-
+  it 'records single from filtering_started to filtering_ended' do
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
     Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
     Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
-    Timecop.freeze(Time.local(2008, 9, 1, 10, 14, 1))
-    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
-    Timecop.freeze(Time.local(2008, 9, 1, 10, 14, 3))
-    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
 
-    expect { listener.stop }
-      .to output(/^\s*erb │     2   1\.00s   1\.50s   2\.00s   3\.00s$/).to_stdout
+    expect(listener.telemetry.summary(:filters).get('erb').min).to eq(1.00)
+    expect(listener.telemetry.summary(:filters).get('erb').avg).to eq(1.00)
+    expect(listener.telemetry.summary(:filters).get('erb').max).to eq(1.00)
+    expect(listener.telemetry.summary(:filters).get('erb').sum).to eq(1.00)
+    expect(listener.telemetry.summary(:filters).get('erb').count).to eq(1.00)
   end
 
-  it 'records inner filters in nested filtering_started/filtering_ended' do
-    listener.start
-
+  it 'records multiple from filtering_started to filtering_ended' do
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
-    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :outer)
+    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
-    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :inner)
-    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 3))
-    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :inner)
-    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 6))
-    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :outer)
+    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 14, 1))
+    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 14, 3))
+    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
 
-    expect { listener.stop }
-      .to output(/^\s*inner │     1   2\.00s   2\.00s   2\.00s   2\.00s$/).to_stdout
+    expect(listener.telemetry.summary(:filters).get('erb').min).to eq(1.00)
+    expect(listener.telemetry.summary(:filters).get('erb').avg).to eq(1.50)
+    expect(listener.telemetry.summary(:filters).get('erb').max).to eq(2.00)
+    expect(listener.telemetry.summary(:filters).get('erb').sum).to eq(3.00)
+    expect(listener.telemetry.summary(:filters).get('erb').count).to eq(2.00)
   end
 
-  it 'records outer filters in nested filtering_started/filtering_ended' do
-    listener.start
-
+  it 'records filters in nested filtering_started/filtering_ended' do
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
     Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :outer)
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
@@ -76,13 +83,20 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 6))
     Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :outer)
 
-    expect { listener.stop }
-      .to output(/^\s*outer │     1   6\.00s   6\.00s   6\.00s   6\.00s$/).to_stdout
+    expect(listener.telemetry.summary(:filters).get('inner').min).to eq(2.00)
+    expect(listener.telemetry.summary(:filters).get('inner').avg).to eq(2.00)
+    expect(listener.telemetry.summary(:filters).get('inner').max).to eq(2.00)
+    expect(listener.telemetry.summary(:filters).get('inner').sum).to eq(2.00)
+    expect(listener.telemetry.summary(:filters).get('inner').count).to eq(1.00)
+
+    expect(listener.telemetry.summary(:filters).get('outer').min).to eq(6.00)
+    expect(listener.telemetry.summary(:filters).get('outer').avg).to eq(6.00)
+    expect(listener.telemetry.summary(:filters).get('outer').max).to eq(6.00)
+    expect(listener.telemetry.summary(:filters).get('outer').sum).to eq(6.00)
+    expect(listener.telemetry.summary(:filters).get('outer').count).to eq(1.00)
   end
 
   it 'pauses outer stopwatch when suspended' do
-    listener.start
-
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
     Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
     Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :outer)
@@ -96,13 +110,14 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :inner)
     Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :outer)
 
-    expect { listener.stop }
-      .to output(/^\s*outer │     1   7\.00s   7\.00s   7\.00s   7\.00s$/).to_stdout
+    expect(listener.telemetry.summary(:filters).get('outer').min).to eq(7.00)
+    expect(listener.telemetry.summary(:filters).get('outer').avg).to eq(7.00)
+    expect(listener.telemetry.summary(:filters).get('outer').max).to eq(7.00)
+    expect(listener.telemetry.summary(:filters).get('outer').sum).to eq(7.00)
+    expect(listener.telemetry.summary(:filters).get('outer').count).to eq(1.00)
   end
 
   it 'records single from filtering_started over compilation_{suspended,started} to filtering_ended' do
-    listener.start
-
     Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
     Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
@@ -113,25 +128,27 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 7))
     Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
 
-    expect { listener.stop }
-      .to output(/^\s*erb │     1   5\.00s   5\.00s   5\.00s   5\.00s$/).to_stdout
+    expect(listener.telemetry.summary(:filters).get('erb').min).to eq(5.00)
+    expect(listener.telemetry.summary(:filters).get('erb').avg).to eq(5.00)
+    expect(listener.telemetry.summary(:filters).get('erb').max).to eq(5.00)
+    expect(listener.telemetry.summary(:filters).get('erb').sum).to eq(5.00)
+    expect(listener.telemetry.summary(:filters).get('erb').count).to eq(1.00)
   end
 
   it 'records single phase start+stop' do
-    listener.start
-
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
     Nanoc::Int::NotificationCenter.post(:phase_started, 'donkey', rep)
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
     Nanoc::Int::NotificationCenter.post(:phase_ended, 'donkey', rep)
 
-    expect { listener.stop }
-      .to output(/^\s*donkey │     1   1\.00s   1\.00s   1\.00s   1\.00s$/).to_stdout
+    expect(listener.telemetry.summary(:phases).get('donkey').min).to eq(1.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').avg).to eq(1.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').max).to eq(1.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').sum).to eq(1.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').count).to eq(1.00)
   end
 
   it 'records multiple phase start+stop' do
-    listener.start
-
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
     Nanoc::Int::NotificationCenter.post(:phase_started, 'donkey', rep)
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
@@ -141,13 +158,14 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     Timecop.freeze(Time.local(2008, 9, 1, 11, 6, 2))
     Nanoc::Int::NotificationCenter.post(:phase_ended, 'donkey', rep)
 
-    expect { listener.stop }
-      .to output(/^\s*donkey │     2   1\.00s   1\.50s   2\.00s   3\.00s$/).to_stdout
+    expect(listener.telemetry.summary(:phases).get('donkey').min).to eq(1.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').avg).to eq(1.50)
+    expect(listener.telemetry.summary(:phases).get('donkey').max).to eq(2.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').sum).to eq(3.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').count).to eq(2.00)
   end
 
   it 'records single phase start+yield+resume+stop' do
-    listener.start
-
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
     Nanoc::Int::NotificationCenter.post(:phase_started, 'donkey', rep)
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
@@ -157,13 +175,14 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     Timecop.freeze(Time.local(2008, 9, 1, 11, 6, 2))
     Nanoc::Int::NotificationCenter.post(:phase_ended, 'donkey', rep)
 
-    expect { listener.stop }
-      .to output(/^\s*donkey │     1   3\.00s   3\.00s   3\.00s   3\.00s$/).to_stdout
+    expect(listener.telemetry.summary(:phases).get('donkey').min).to eq(3.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').avg).to eq(3.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').max).to eq(3.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').sum).to eq(3.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').count).to eq(1.00)
   end
 
   it 'records single phase start+yield+abort+start+stop' do
-    listener.start
-
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
     Nanoc::Int::NotificationCenter.post(:phase_started, 'donkey', rep)
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
@@ -175,13 +194,24 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     Timecop.freeze(Time.local(2008, 9, 1, 12, 7, 5))
     Nanoc::Int::NotificationCenter.post(:phase_ended, 'donkey', rep)
 
-    expect { listener.stop }
-      .to output(/^\s*donkey │     2   1\.00s   2\.00s   3\.00s   4\.00s$/).to_stdout
+    expect(listener.telemetry.summary(:phases).get('donkey').min).to eq(1.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').avg).to eq(2.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').max).to eq(3.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').sum).to eq(4.00)
+    expect(listener.telemetry.summary(:phases).get('donkey').count).to eq(2.00)
   end
 
   it 'records stage duration' do
-    listener.start
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:stage_started, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:stage_ended, 'donkey', rep)
 
+    expect(listener.telemetry.summary(:stages).get('donkey').sum).to eq(1.00)
+    expect(listener.telemetry.summary(:stages).get('donkey').count).to eq(1.00)
+  end
+
+  it 'prints stage durations' do
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
     Nanoc::Int::NotificationCenter.post(:stage_started, 'donkey', rep)
     Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
@@ -190,4 +220,44 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     expect { listener.stop }
       .to output(/^\s*donkey │ 1\.00s$/).to_stdout
   end
+
+  it 'prints out outdatedness rule durations' do
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:outdatedness_rule_started, Nanoc::Int::OutdatednessRules::CodeSnippetsModified, rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:outdatedness_rule_ended, Nanoc::Int::OutdatednessRules::CodeSnippetsModified, rep)
+
+    expect { listener.stop }
+      .to output(/^\s*CodeSnippetsModified │     1   1\.00s   1\.00s   1\.00s   1\.00s   1\.00s   1\.00s$/).to_stdout
+  end
+
+  it 'records single outdatedness rule duration' do
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:outdatedness_rule_started, Nanoc::Int::OutdatednessRules::CodeSnippetsModified, rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:outdatedness_rule_ended, Nanoc::Int::OutdatednessRules::CodeSnippetsModified, rep)
+
+    expect(listener.telemetry.summary(:outdatedness_rules).get('CodeSnippetsModified').min).to eq(1.00)
+    expect(listener.telemetry.summary(:outdatedness_rules).get('CodeSnippetsModified').avg).to eq(1.00)
+    expect(listener.telemetry.summary(:outdatedness_rules).get('CodeSnippetsModified').max).to eq(1.00)
+    expect(listener.telemetry.summary(:outdatedness_rules).get('CodeSnippetsModified').sum).to eq(1.00)
+    expect(listener.telemetry.summary(:outdatedness_rules).get('CodeSnippetsModified').count).to eq(1.00)
+  end
+
+  it 'records multiple outdatedness rule duration' do
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:outdatedness_rule_started, Nanoc::Int::OutdatednessRules::CodeSnippetsModified, rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:outdatedness_rule_ended, Nanoc::Int::OutdatednessRules::CodeSnippetsModified, rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 6, 0))
+    Nanoc::Int::NotificationCenter.post(:outdatedness_rule_started, Nanoc::Int::OutdatednessRules::CodeSnippetsModified, other_rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 6, 3))
+    Nanoc::Int::NotificationCenter.post(:outdatedness_rule_ended, Nanoc::Int::OutdatednessRules::CodeSnippetsModified, other_rep)
+
+    expect(listener.telemetry.summary(:outdatedness_rules).get('CodeSnippetsModified').min).to eq(1.00)
+    expect(listener.telemetry.summary(:outdatedness_rules).get('CodeSnippetsModified').avg).to eq(2.00)
+    expect(listener.telemetry.summary(:outdatedness_rules).get('CodeSnippetsModified').max).to eq(3.00)
+    expect(listener.telemetry.summary(:outdatedness_rules).get('CodeSnippetsModified').sum).to eq(4.00)
+    expect(listener.telemetry.summary(:outdatedness_rules).get('CodeSnippetsModified').count).to eq(2.00)
+  end
 end