rspec-tap-formatters 0.1.0

data/spec/rspec/tap/formatters/flat_spec.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+RSpec.describe RSpec::TAP::Formatters::Flat do
+  subject(:formatter) { described_class.new(report_output) }
+
+  let(:report_output) { StringIO.new }
+  let(:report_printer) { RSpec::TAP::Formatters::Printer.new(report_output) }
+
+  before do
+    formatter.instance_variable_set(:@printer, report_printer)
+    formatter.instance_variable_set(:@seed, nil)
+    formatter.instance_variable_set(:@example_number, 0)
+  end
+
+  describe '#seed' do
+    let(:seed) { SecureRandom.random_number(10_000) }
+
+    context 'with seed used' do
+      let(:notification) { OpenStruct.new(seed: seed, seed_used?: true) }
+
+      it 'updates instance variable' do
+        expect { formatter.seed(notification) }
+          .to change { formatter.instance_variable_get(:@seed) }
+          .from(nil)
+          .to(seed)
+      end
+    end
+
+    context 'without seed used' do
+      let(:notification) { OpenStruct.new(seed: seed, seed_used?: false) }
+
+      it 'does not update instance variable' do
+        expect { formatter.seed(notification) }
+          .not_to change { formatter.instance_variable_get(:@seed) }
+      end
+    end
+  end
+
+  describe '#start' do
+    let(:count) { 1 + SecureRandom.random_number(5) }
+    let(:notification) { OpenStruct.new(count: count) }
+
+    it 'delegates to printer' do
+      allow(report_printer).to receive(:start_output)
+
+      formatter.start(notification)
+
+      expect(report_printer).to have_received(:start_output).with(no_args)
+    end
+  end
+
+  describe '#start_dump' do
+    it 'delegates to printer' do
+      allow(report_printer).to receive(:example_progress_dump)
+
+      formatter.start_dump(OpenStruct.new)
+
+      expect(report_printer).to have_received(:example_progress_dump)
+        .with(no_args)
+    end
+  end
+
+  describe '#example_started' do
+    let(:example_number) { 1 + SecureRandom.random_number(5) }
+
+    it 'increments example number by one' do
+      expect { formatter.example_started(OpenStruct.new) }
+        .to change { formatter.instance_variable_get(:@example_number) }
+        .by(1)
+    end
+  end
+
+  describe '#example_passed' do
+    let(:example_number) { 1 + SecureRandom.random_number(5) }
+    let(:example_status) { :success }
+    let(:example_status_index) { 1 }
+
+    let(:description) { 'example-foo' }
+    let(:example) { OpenStruct.new(full_description: description) }
+    let(:notification) { OpenStruct.new(example: example) }
+
+    before do
+      formatter.instance_variable_set(:@example_number, example_number)
+    end
+
+    it 'delegates progress report to printer' do
+      allow(report_printer).to receive(:example_progress_output)
+
+      formatter.example_passed(notification)
+
+      expect(report_printer).to have_received(:example_progress_output)
+        .with(example_status)
+    end
+
+    it 'delegates status report to printer' do
+      allow(report_printer).to receive(:success_output)
+
+      formatter.example_passed(notification)
+
+      expect(report_printer).to have_received(:success_output)
+        .with(description, example_number, 0)
+    end
+  end
+
+  describe '#example_failed' do
+    let(:example_number) { 1 + SecureRandom.random_number(5) }
+    let(:example_status) { :failure }
+    let(:example_status_index) { 2 }
+
+    let(:description) { 'example-foo' }
+    let(:example) { OpenStruct.new(full_description: description) }
+    let(:notification) { OpenStruct.new(example: example) }
+
+    before do
+      formatter.instance_variable_set(:@example_number, example_number)
+
+      allow(report_printer).to receive(:failure_reason_output)
+    end
+
+    it 'delegates progress report to printer' do
+      allow(report_printer).to receive(:example_progress_output)
+
+      formatter.example_failed(notification)
+
+      expect(report_printer).to have_received(:example_progress_output)
+        .with(example_status)
+    end
+
+    it 'delegates status report to printer' do
+      allow(report_printer).to receive(:failure_output)
+
+      formatter.example_failed(notification)
+
+      expect(report_printer).to have_received(:failure_output)
+        .with(description, example_number, 0)
+    end
+
+    it 'delegates reason to printer' do
+      formatter.example_failed(notification)
+
+      expect(report_printer).to have_received(:failure_reason_output)
+        .with(notification, 1)
+    end
+  end
+
+  describe '#example_pending' do
+    let(:example_number) { 1 + SecureRandom.random_number(5) }
+    let(:example_status) { :pending }
+    let(:example_status_index) { 3 }
+
+    let(:description) { 'example-foo' }
+    let(:example) do
+      OpenStruct.new(
+        full_description: description,
+        execution_result: execution_result
+      )
+    end
+    let(:notification) { OpenStruct.new(example: example) }
+
+    before do
+      formatter.instance_variable_set(:@example_number, example_number)
+    end
+
+    shared_examples_for 'pending example' do
+      it 'delegates progress report to printer' do
+        allow(report_printer).to receive(:example_progress_output)
+
+        formatter.example_pending(notification)
+
+        expect(report_printer).to have_received(:example_progress_output)
+          .with(example_status)
+      end
+
+      it 'delegates status report to printer' do
+        allow(report_printer).to receive(:pending_output)
+
+        formatter.example_pending(notification)
+
+        expect(report_printer).to have_received(:pending_output)
+          .with(notification, description, example_number, 0)
+      end
+    end
+
+    context 'with pending' do
+      let(:pending_message) { "pending-#{SecureRandom.hex}" }
+      let(:directive) { "TODO: #{pending_message}" }
+      let(:execution_result) do
+        OpenStruct.new(
+          pending_message: pending_message,
+          example_skipped?: false
+        )
+      end
+
+      include_examples('pending example')
+    end
+
+    context 'with skipped' do
+      let(:pending_message) { "skip-#{SecureRandom.hex}" }
+      let(:directive) { "SKIP: #{pending_message}" }
+      let(:execution_result) do
+        OpenStruct.new(
+          pending_message: pending_message,
+          example_skipped?: true
+        )
+      end
+
+      include_examples('pending example')
+    end
+  end
+
+  describe '#message' do
+    let(:notification) { OpenStruct.new }
+
+    it 'delegates to printer' do
+      allow(report_printer).to receive(:message_output)
+
+      formatter.message(notification)
+
+      expect(report_printer).to have_received(:message_output)
+        .with(notification)
+    end
+  end
+
+  describe '#dump_failures' do
+    let(:notification) { OpenStruct.new }
+
+    it 'delegates to printer' do
+      allow(report_printer).to receive(:store_failed_examples_summary)
+
+      formatter.dump_failures(notification)
+
+      expect(report_printer).to have_received(:store_failed_examples_summary)
+        .with(notification)
+    end
+  end
+
+  describe '#dump_pending' do
+    let(:notification) { OpenStruct.new }
+
+    it 'delegates to printer' do
+      allow(report_printer).to receive(:store_pending_examples_summary)
+
+      formatter.dump_pending(notification)
+
+      expect(report_printer).to have_received(:store_pending_examples_summary)
+        .with(notification)
+    end
+  end
+
+  describe '#dump_summary' do
+    let(:seed) { 1 + SecureRandom.random_number(10_000) }
+    let(:notification) { OpenStruct.new }
+
+    it 'delegates to printer' do
+      allow(report_printer).to receive(:summary_output)
+
+      formatter.instance_variable_set(:@seed, seed)
+      formatter.dump_summary(notification)
+
+      expect(report_printer).to have_received(:summary_output)
+        .with(notification, seed)
+    end
+  end
+end

data/spec/rspec/tap/formatters/printer_spec.rb

@@ -0,0 +1,1075 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+RSpec.shared_context 'when writing to file' do
+  before do
+    report_printer.instance_variable_set(:@write_to_file, true)
+    report_printer.instance_variable_set(:@display_colors, false)
+  end
+end
+
+RSpec.shared_context 'when not writing to file' do
+  before do
+    report_printer.instance_variable_set(:@write_to_file, false)
+    report_printer.instance_variable_set(:@display_colors, true)
+  end
+end
+
+RSpec.describe RSpec::TAP::Formatters::Printer do
+  subject(:report_printer) { described_class.new(report_output) }
+
+  let(:report_output) { StringIO.new }
+
+  before do
+    report_printer.instance_variable_set(:@output, report_output)
+    report_printer.instance_variable_set(:@write_to_file, false)
+    report_printer.instance_variable_set(:@display_colors, true)
+    report_printer.instance_variable_set(:@force_colors, false)
+    report_printer.instance_variable_set(:@bailed_out, false)
+    report_printer.instance_variable_set(:@failed_examples, '')
+    report_printer.instance_variable_set(:@pending_examples, '')
+  end
+
+  describe '#start_output' do
+    context 'when bailed out' do
+      it 'outputs nothing' do
+        report_printer.instance_variable_set(:@bailed_out, true)
+        report_printer.start_output
+
+        expect(report_output.string).to be_empty
+      end
+    end
+
+    context 'when not bailed out' do
+      let(:output_line) { 'TAP version 13' }
+
+      it 'outputs tap version with tests count' do
+        report_printer.start_output
+
+        expect(report_output.string.chomp).to eq(output_line)
+      end
+    end
+  end
+
+  describe '#group_start_output' do
+    let(:description) { 'test-or-group-foo' }
+    let(:group) { OpenStruct.new(description: description) }
+    let(:notification) { OpenStruct.new(group: group) }
+
+    shared_context 'when root level test' do
+      let(:padding) { 0 }
+      let(:indentation) { '  ' * padding }
+
+      before do
+        report_printer.group_start_output(notification, padding)
+      end
+    end
+
+    shared_context 'when non-root level test' do
+      let(:padding) { 1 + SecureRandom.random_number(5) }
+      let(:indentation) { '  ' * padding }
+
+      before do
+        report_printer.group_start_output(notification, padding)
+      end
+    end
+
+    context 'with colorized outputs' do
+      before do
+        allow(RSpec::Core::Formatters::ConsoleCodes)
+          .to receive(:wrap) do |string, status|
+            "<#{status}>#{string}</#{status}>"
+          end
+
+        report_printer.instance_variable_set(:@display_colors, true)
+      end
+
+      context 'when root level test' do
+        let(:uncolorized_output_line) do
+          "#{indentation}# test: #{description} {"
+        end
+        let(:output_line) do
+          "<detail>#{uncolorized_output_line}</detail>"
+        end
+
+        include_context('when root level test')
+
+        it 'outputs test information' do
+          expect(report_output.string.chomp).to eq(output_line)
+        end
+
+        it 'outputs colorized test information' do
+          expect(RSpec::Core::Formatters::ConsoleCodes)
+            .to have_received(:wrap)
+            .with(a_string_equal_to(uncolorized_output_line), :detail)
+        end
+      end
+
+      context 'when non-root level test' do
+        let(:uncolorized_output_line) do
+          "#{indentation}# group: #{description} {"
+        end
+        let(:output_line) do
+          "<detail>#{uncolorized_output_line}</detail>"
+        end
+
+        include_context('when non-root level test')
+
+        it 'outputs group information' do
+          expect(report_output.string.chomp).to eq(output_line)
+        end
+
+        it 'outputs colorized group information' do
+          expect(RSpec::Core::Formatters::ConsoleCodes)
+            .to have_received(:wrap)
+            .with(a_string_equal_to(uncolorized_output_line), :detail)
+        end
+      end
+    end
+
+    context 'without colorized outputs' do
+      before do
+        allow(RSpec::Core::Formatters::ConsoleCodes)
+          .to receive(:wrap).with(String, Symbol)
+
+        report_printer.instance_variable_set(:@display_colors, false)
+      end
+
+      context 'when root level test' do
+        let(:output_line) { "#{indentation}# test: #{group.description} {" }
+
+        include_context('when root level test')
+
+        it 'outputs test information' do
+          expect(report_output.string.chomp).to eq(output_line)
+        end
+
+        it 'outputs non-colorized test information' do
+          expect(RSpec::Core::Formatters::ConsoleCodes)
+            .not_to have_received(:wrap)
+        end
+      end
+
+      context 'when non-root level test' do
+        let(:output_line) { "#{indentation}# group: #{group.description} {" }
+
+        include_context('when non-root level test')
+
+        it 'outputs group information' do
+          expect(report_output.string.chomp).to eq(output_line)
+        end
+
+        it 'outputs non-colorized group information' do
+          expect(RSpec::Core::Formatters::ConsoleCodes)
+            .not_to have_received(:wrap)
+        end
+      end
+    end
+  end
+
+  describe '#group_finished_output' do
+    let(:padding) { 1 + SecureRandom.random_number(5) }
+    let(:indentation) { '  ' * padding }
+    let(:indentation_one_level_up) { '  ' * (padding - 1) }
+
+    let(:passed) { 1 + SecureRandom.random_number(5) }
+    let(:failed) { 1 + SecureRandom.random_number(5) }
+    let(:pending) { 0 }
+    let(:tests) { passed + failed + pending }
+    let(:test_stats) { [tests, passed, failed, pending] }
+
+    context 'with colorized outputs' do
+      let(:uncolorized_output_line) { "#{indentation_one_level_up}}" }
+      let(:output_line) do
+        <<-OUTPUT.gsub(/^\s+\|/, '').chomp
+          |#{indentation}1..#{tests}
+          |#{indentation}# tests: #{tests}, passed: #{passed}, failed: #{failed}
+          |<detail>#{uncolorized_output_line}</detail>
+        OUTPUT
+      end
+
+      before do
+        allow(RSpec::Core::Formatters::ConsoleCodes)
+          .to receive(:wrap) do |string, status|
+            "<#{status}>#{string}</#{status}>"
+          end
+
+        report_printer.instance_variable_set(:@display_colors, true)
+        report_printer.group_finished_output(test_stats, padding)
+      end
+
+      it 'outputs tests summary' do
+        expect(report_output.string.chomp).to eq(output_line)
+      end
+
+      it 'outputs colorized tests summary' do
+        expect(RSpec::Core::Formatters::ConsoleCodes)
+          .to have_received(:wrap)
+          .with(a_string_equal_to(uncolorized_output_line), :detail)
+      end
+    end
+
+    context 'without colorized outputs' do
+      let(:output_line) do
+        <<-OUTPUT.gsub(/^\s+\|/, '').chomp
+          |#{indentation}1..#{tests}
+          |#{indentation}# tests: #{tests}, passed: #{passed}, failed: #{failed}
+          |#{indentation_one_level_up}}
+        OUTPUT
+      end
+
+      before do
+        allow(RSpec::Core::Formatters::ConsoleCodes)
+          .to receive(:wrap).with(String, Symbol)
+
+        report_printer.instance_variable_set(:@display_colors, false)
+        report_printer.group_finished_output(test_stats, padding)
+      end
+
+      it 'outputs tests summary' do
+        expect(report_output.string.chomp).to eq(output_line)
+      end
+
+      it 'outputs non-colorized tests summary' do
+        expect(RSpec::Core::Formatters::ConsoleCodes)
+          .not_to have_received(:wrap)
+      end
+    end
+  end
+
+  describe '#example_progress_output' do
+    shared_examples_for 'example progress output' do |char, status|
+      context 'when writing to file' do
+        include_context('when writing to file')
+
+        context 'with forced colorized outputs' do
+          let(:progress_output) { "<#{status}>#{char}</#{status}>" }
+
+          before do
+            allow(RSpec::Core::Formatters::ConsoleCodes)
+              .to receive(:wrap) do |string, color|
+                "<#{color}>#{string}</#{color}>"
+              end
+
+            allow(RSpec).to receive(:configuration)
+              .with(no_args)
+              .and_return(OpenStruct.new(color_enabled?: true))
+          end
+
+          it 'outputs example progress' do
+            expect { report_printer.example_progress_output(status) }
+              .to output(progress_output).to_stdout
+          end
+
+          it 'outputs colorized example progress' do
+            report_printer.example_progress_output(status)
+
+            expect(RSpec::Core::Formatters::ConsoleCodes)
+              .to have_received(:wrap)
+              .with(a_string_equal_to(char), status)
+          end
+
+          it 'outputs forced colorized example progress' do
+            report_printer.example_progress_output(status)
+
+            expect(RSpec).to have_received(:configuration).with(no_args)
+          end
+        end
+
+        context 'without colorized outputs' do
+          let(:progress_output) { char }
+
+          before do
+            allow(RSpec::Core::Formatters::ConsoleCodes)
+              .to receive(:wrap).with(String, Symbol)
+
+            allow(RSpec).to receive(:configuration)
+              .with(no_args).and_return(OpenStruct.new(color_enabled?: false))
+          end
+
+          it 'outputs example progress' do
+            expect { report_printer.example_progress_output(status) }
+              .to output(progress_output).to_stdout
+          end
+
+          it 'outputs non-colorized example progress' do
+            report_printer.example_progress_output(status)
+
+            expect(RSpec::Core::Formatters::ConsoleCodes)
+              .not_to have_received(:wrap)
+          end
+
+          it 'outputs non-forced colorized example progress' do
+            report_printer.example_progress_output(status)
+
+            expect(RSpec).to have_received(:configuration).with(no_args)
+          end
+        end
+      end
+
+      context 'when not writing to file' do
+        before do
+          allow(RSpec::Core::Formatters::ConsoleCodes)
+            .to receive(:wrap).with(String, Symbol)
+
+          allow(RSpec).to receive(:configuration)
+            .with(no_args).and_return(OpenStruct.new)
+        end
+
+        include_context('when not writing to file')
+
+        it 'does not output example progress' do
+          expect { report_printer.example_progress_output(status) }
+            .not_to output.to_stdout
+        end
+
+        it 'does not attempt to colorize output' do
+          report_printer.example_progress_output(status)
+
+          expect(RSpec::Core::Formatters::ConsoleCodes)
+            .not_to have_received(:wrap)
+        end
+
+        it 'does not attempt to force colorize output' do
+          report_printer.example_progress_output(status)
+
+          expect(RSpec).not_to have_received(:configuration)
+        end
+      end
+    end
+
+    context 'with success progress' do
+      include_examples('example progress output', '.', :success)
+    end
+
+    context 'with failure progress' do
+      include_examples('example progress output', 'F', :failure)
+    end
+
+    context 'with success progress' do
+      include_examples('example progress output', '*', :pending)
+    end
+  end
+
+  describe '#example_progress_dump' do
+    context 'when writing to file' do
+      include_context('when writing to file')
+
+      it 'outputs a blank line' do
+        expect { report_printer.example_progress_dump }
+          .to output("\n").to_stdout
+      end
+    end
+
+    context 'without writing to file' do
+      include_context('when not writing to file')
+
+      it 'outputs nothing' do
+        expect { report_printer.example_progress_dump }
+          .not_to output.to_stdout
+      end
+    end
+  end
+
+  describe '#success_output' do
+    let(:padding) { 3 }
+    let(:indentation) { '  ' * padding }
+    let(:description) { 'example-foo' }
+    let(:example_number) { 1 + SecureRandom.random_number(5) }
+
+    context 'with colorized outputs' do
+      let(:uncolorized_output_line) do
+        "#{indentation}ok #{example_number} - #{description}"
+      end
+      let(:output_line) do
+        "<success>#{uncolorized_output_line}</success>"
+      end
+
+      before do
+        allow(RSpec::Core::Formatters::ConsoleCodes)
+          .to receive(:wrap) do |string, status|
+            "<#{status}>#{string}</#{status}>"
+          end
+
+        report_printer.instance_variable_set(:@display_colors, true)
+      end
+
+      it 'outputs example status' do
+        report_printer.success_output(description, example_number, padding)
+
+        expect(report_output.string.chomp).to eq(output_line)
+      end
+
+      it 'outputs colorized status' do
+        report_printer.success_output(description, example_number, padding)
+
+        expect(RSpec::Core::Formatters::ConsoleCodes)
+          .to have_received(:wrap)
+          .with(a_string_equal_to(uncolorized_output_line), :success)
+      end
+    end
+
+    context 'without colorized outputs' do
+      let(:output_line) do
+        "#{indentation}ok #{example_number} - #{description}"
+      end
+
+      before do
+        allow(RSpec::Core::Formatters::ConsoleCodes).to receive(:wrap)
+
+        report_printer.instance_variable_set(:@display_colors, false)
+      end
+
+      it 'outputs example status' do
+        report_printer.success_output(description, example_number, padding)
+
+        expect(report_output.string.chomp).to eq(output_line)
+      end
+
+      it 'outputs non-colorized example status' do
+        report_printer.success_output(description, example_number, padding)
+
+        expect(RSpec::Core::Formatters::ConsoleCodes)
+          .not_to have_received(:wrap)
+      end
+    end
+  end
+
+  describe '#failure_output' do
+    let(:padding) { 3 }
+    let(:indentation) { '  ' * padding }
+    let(:description) { 'example-foo' }
+    let(:example_number) { 1 + SecureRandom.random_number(5) }
+
+    context 'with colorized outputs' do
+      let(:uncolorized_output_line) do
+        "#{indentation}not ok #{example_number} - #{description}"
+      end
+      let(:output_line) do
+        "<failure>#{uncolorized_output_line}</failure>"
+      end
+
+      before do
+        allow(RSpec::Core::Formatters::ConsoleCodes)
+          .to receive(:wrap) do |string, status|
+            "<#{status}>#{string}</#{status}>"
+          end
+
+        report_printer.instance_variable_set(:@display_colors, true)
+      end
+
+      it 'outputs example status' do
+        report_printer.failure_output(description, example_number, padding)
+
+        expect(report_output.string.chomp).to eq(output_line)
+      end
+
+      it 'outputs colorized status' do
+        report_printer.failure_output(description, example_number, padding)
+
+        expect(RSpec::Core::Formatters::ConsoleCodes)
+          .to have_received(:wrap)
+          .with(a_string_equal_to(uncolorized_output_line), :failure)
+      end
+    end
+
+    context 'without colorized outputs' do
+      let(:output_line) do
+        "#{indentation}not ok #{example_number} - #{description}"
+      end
+
+      before do
+        allow(RSpec::Core::Formatters::ConsoleCodes).to receive(:wrap)
+
+        report_printer.instance_variable_set(:@display_colors, false)
+      end
+
+      it 'outputs example status' do
+        report_printer.failure_output(description, example_number, padding)
+
+        expect(report_output.string.chomp).to eq(output_line)
+      end
+
+      it 'outputs non-colorized example status' do
+        report_printer.failure_output(description, example_number, padding)
+
+        expect(RSpec::Core::Formatters::ConsoleCodes)
+          .not_to have_received(:wrap)
+      end
+    end
+  end
+
+  describe '#failure_reason_output' do
+    let(:padding) { 4 }
+    let(:indentation) { '  ' * padding }
+    let(:indentation_one_level_down) { '  ' * (padding + 1) }
+    let(:location) do
+      "./spec/foo_spec.rb:#{1 + SecureRandom.random_number(5)}"
+    end
+
+    shared_examples_for 'failure reason for non-aggregate failures' do
+      context 'without aggregate failures' do
+        let(:message_lines) { %w[first_line second_line] }
+        let(:formatted_backtrace) { %w[trace_first trace_second trace_third] }
+        let(:exception) { RSpec::Expectations::ExpectationNotMetError.new }
+        let(:example) do
+          OpenStruct.new(
+            execution_result: OpenStruct.new(exception: exception),
+            metadata: {
+              location: location
+            }
+          )
+        end
+        let(:notification) do
+          OpenStruct.new(
+            message_lines: message_lines,
+            formatted_backtrace: formatted_backtrace,
+            example: example
+          )
+        end
+
+        let(:failure_diagnostics) do
+          diagnostics = <<-DIAGNOSTICS.gsub(/^\s+\|/, '').chomp
+            |---
+            |location: "#{location}"
+            |error: |-
+            |  first_line
+            |  second_line
+            |backtrace: |-
+            |  trace_first
+            |  trace_second
+            |  trace_third
+            |...
+          DIAGNOSTICS
+
+          diagnostics.lines
+            .map { |line| "#{indentation_one_level_down}#{line}" }
+            .join
+        end
+
+        it 'outputs failure diagnostics' do
+          report_printer.failure_reason_output(notification, padding + 1)
+
+          expect(report_output.string.chomp).to eq(failure_diagnostics)
+        end
+      end
+    end
+
+    shared_examples_for 'failure reason output without diagnostics' do
+      context 'without diagnostics' do
+        let(:example) do
+          OpenStruct.new(
+            execution_result: OpenStruct.new(
+              exception: RSpec::Expectations::ExpectationNotMetError.new
+            ),
+            metadata: {
+              location: location
+            }
+          )
+        end
+        let(:notification) do
+          OpenStruct.new(
+            message_lines: [],
+            formatted_backtrace: [],
+            example: example
+          )
+        end
+
+        it 'outputs nothing' do
+          report_printer.failure_reason_output(notification, padding)
+
+          expect(report_output.string).to be_empty
+        end
+      end
+    end
+
+    if Gem::Version.new(RSpec::Core::Version::STRING) >=
+       Gem::Version.new('3.3.0')
+      context 'with RSpec version >= 3.3.0' do
+        before do
+          stub_const('RSpec::Core::Version::STRING', '3.3.1')
+        end
+
+        context 'with diagnostics' do
+          context 'with aggregate failures' do
+            let(:exception) do
+              RSpec::Expectations::MultipleExpectationsNotMetError.new
+            end
+            let(:example) do
+              OpenStruct.new(
+                execution_result: OpenStruct.new(exception: exception),
+                metadata: {
+                  location: location
+                }
+              )
+            end
+            let(:notification) { OpenStruct.new(example: example) }
+
+            let(:failure_diagnostics) do
+              diagnostics = <<-DIAGNOSTICS.gsub(/^\s+\|/, '').chomp
+              |---
+              |location: "#{location}"
+              |error: RSpec::Expectations::MultipleExpectationsNotMetError
+              |...
+              DIAGNOSTICS
+
+              diagnostics.lines
+                .map { |line| "#{indentation_one_level_down}#{line}" }
+                .join
+            end
+
+            it 'outputs failure diagnostics' do
+              report_printer.failure_reason_output(notification, padding + 1)
+
+              expect(report_output.string.chomp).to eq(failure_diagnostics)
+            end
+          end
+
+          include_examples('failure reason for non-aggregate failures')
+        end
+
+        include_examples('failure reason output without diagnostics')
+      end
+    end
+
+    context 'with RSpec version less than 3.3.0' do
+      before do
+        stub_const('RSpec::Core::Version::STRING', '3.2.9')
+      end
+
+      context 'with diagnostics' do
+        include_examples('failure reason for non-aggregate failures')
+      end
+
+      include_examples('failure reason output without diagnostics')
+    end
+  end
+
+  describe '#pending_output' do
+    let(:padding) { 3 }
+    let(:indentation) { '  ' * padding }
+    let(:description) { 'example-foo' }
+    let(:example_number) { 1 + SecureRandom.random_number(5) }
+    let(:pending_message) { "pending-#{SecureRandom.hex}" }
+    let(:directive) { "TODO: #{pending_message}" }
+    let(:execution_result) do
+      OpenStruct.new(
+        pending_message: pending_message,
+        example_skipped?: false
+      )
+    end
+    let(:example) do
+      OpenStruct.new(
+        description: description,
+        execution_result: execution_result
+      )
+    end
+    let(:notification) { OpenStruct.new(example: example) }
+
+    context 'with colorized outputs' do
+      let(:uncolorized_output_line) do
+        "#{indentation}ok #{example_number} - #{description} # #{directive}"
+      end
+      let(:output_line) do
+        "<pending>#{uncolorized_output_line}</pending>"
+      end
+
+      before do
+        allow(RSpec::Core::Formatters::ConsoleCodes)
+          .to receive(:wrap) do |string, status|
+            "<#{status}>#{string}</#{status}>"
+          end
+
+        report_printer.instance_variable_set(:@display_colors, true)
+      end
+
+      it 'outputs example status' do
+        report_printer.pending_output(
+          notification,
+          description,
+          example_number,
+          padding
+        )
+
+        expect(report_output.string.chomp).to eq(output_line)
+      end
+
+      it 'outputs colorized status' do
+        report_printer.pending_output(
+          notification,
+          description,
+          example_number,
+          padding
+        )
+
+        expect(RSpec::Core::Formatters::ConsoleCodes)
+          .to have_received(:wrap)
+          .with(a_string_equal_to(uncolorized_output_line), :pending)
+      end
+    end
+
+    context 'without colorized outputs' do
+      let(:output_line) do
+        "#{indentation}ok #{example_number} - #{description} # #{directive}"
+      end
+
+      before do
+        allow(RSpec::Core::Formatters::ConsoleCodes).to receive(:wrap)
+
+        report_printer.instance_variable_set(:@display_colors, false)
+      end
+
+      it 'outputs example status' do
+        report_printer.pending_output(
+          notification,
+          description,
+          example_number,
+          padding
+        )
+
+        expect(report_output.string.chomp).to eq(output_line)
+      end
+
+      it 'outputs non-colorized example status' do
+        report_printer.pending_output(
+          notification,
+          description,
+          example_number,
+          padding
+        )
+
+        expect(RSpec::Core::Formatters::ConsoleCodes)
+          .not_to have_received(:wrap)
+      end
+    end
+  end
+
+  describe '#message_output' do
+    context 'when bailed out' do
+      it 'outputs nothing' do
+        report_printer.instance_variable_set(:@bailed_out, true)
+        report_printer.message_output(OpenStruct.new)
+
+        expect(report_output.string).to be_empty
+      end
+    end
+
+    context 'when failure inside example' do
+      before do
+        allow(RSpec).to receive(:world).with(no_args)
+          .and_return(OpenStruct.new(non_example_failure: false))
+      end
+
+      it 'outputs nothing' do
+        report_printer.message_output(OpenStruct.new)
+
+        expect(report_output.string).to be_empty
+      end
+
+      it 'verifies failure type' do
+        report_printer.message_output(OpenStruct.new)
+
+        expect(RSpec).to have_received(:world)
+      end
+    end
+
+    context 'when failure outside example' do
+      let(:message) do
+        <<-MESSAGE.gsub(/^\s+\|/, '').chomp
+          |message foo
+          |
+          |bar message
+          |# baz qux message
+          |\033[0;31m# colored message quux\033[0m
+        MESSAGE
+      end
+      let(:notification) { OpenStruct.new(message: message) }
+
+      let(:output_line) do
+        <<-OUTPUT.gsub(/^\s+\|/, '').chomp
+          |TAP version 13
+          |1..0
+          |Bail out!
+          |# message foo
+          |# bar message
+          |# baz qux message
+          |# colored message quux
+        OUTPUT
+      end
+
+      before do
+        allow(RSpec).to receive(:world).with(no_args)
+          .and_return(OpenStruct.new(non_example_failure: true))
+      end
+
+      it 'outputs message' do
+        report_printer.message_output(notification)
+
+        expect(report_output.string.chomp).to eq(output_line)
+      end
+
+      it 'verifies failure type' do
+        report_printer.message_output(notification)
+
+        expect(RSpec).to have_received(:world)
+      end
+
+      it 'marks execution bailed-out' do
+        expect { report_printer.message_output(notification) }
+          .to change { report_printer.instance_variable_get(:@bailed_out) }
+          .from(false)
+          .to(true)
+      end
+    end
+  end
+
+  describe '#store_failed_examples_summary' do
+    context 'with failed examples' do
+      let(:failed_examples) do
+        <<-FAILURES.gsub(/^\s+\|/, '').chomp
+          |Failure:
+          |
+          |  1) sample spec fails
+          |     Failure/Error: expect(1).to eq(2)
+          |
+          |       expected: 2
+          |            got: 1
+          |
+          |       (compared using ==)
+          |     # ./spec/rspec/string_spec.rb:13
+          |  2) sample spec fails twice
+          |     Got 2 failures:
+          |
+          |     2.1) Failure/Error: expect(1).to eq(2)
+          |
+          |            expected: 2
+          |                 got: 1
+          |
+          |            (compared using ==)
+          |          # ./spec/rspec/string_spec.rb:23
+          |
+          |     2.2) Failure/Error: expect(3).to eq(4)
+          |
+          |            expected: 4
+          |                 got: 3
+          |
+          |            (compared using ==)
+          |          # ./spec/rspec/string_spec.rb:24
+        FAILURES
+      end
+      let(:notification) do
+        OpenStruct.new(
+          failure_notifications: %i[failure-foo failure-baz],
+          fully_formatted_failed_examples: failed_examples
+        )
+      end
+
+      it 'updates failed examples' do
+        expect { report_printer.store_failed_examples_summary(notification) }
+          .to change {
+            report_printer.instance_variable_get(:@failed_examples)
+          }
+          .from('')
+          .to(failed_examples)
+      end
+    end
+
+    context 'without failed examples' do
+      let(:notification) do
+        OpenStruct.new(failure_notifications: [])
+      end
+
+      it 'does not update failed examples' do
+        expect { report_printer.store_failed_examples_summary(notification) }
+          .not_to change {
+            report_printer.instance_variable_get(:@failed_examples)
+          }
+      end
+    end
+  end
+
+  describe '#store_pending_examples_summary' do
+    context 'with pending examples' do
+      let(:pending_examples) do
+        <<-PENDING.gsub(/^\s+\|/, '').chomp
+          |Pending: (Failures listed here are expected and do not affect your suite's status)
+          |
+          |  1) sample spec without implementation succeeds
+          |     # Not yet implemented
+          |     # ./spec/rspec/string_spec.rb:8
+          |
+          |  2) sample spec with unmet expectation also succeeds
+          |     # No reason given
+          |     Failure/Error: expect(1).to eq(2)
+          |
+          |       expected: 2
+          |            got: 1
+          |
+          |       (compared using ==)
+          |     # ./spec/rspec/string_spec.rb:18
+        PENDING
+      end
+      let(:notification) do
+        OpenStruct.new(
+          pending_examples: %i[peding-baz pending-qux],
+          fully_formatted_pending_examples: pending_examples
+        )
+      end
+
+      it 'updates pending examples' do
+        expect { report_printer.store_pending_examples_summary(notification) }
+          .to change {
+            report_printer.instance_variable_get(:@pending_examples)
+          }
+          .from('')
+          .to(pending_examples)
+      end
+    end
+
+    context 'without pending examples' do
+      let(:notification) do
+        OpenStruct.new(pending_examples: [])
+      end
+
+      it 'does not update pending examples' do
+        expect { report_printer.store_pending_examples_summary(notification) }
+          .not_to change {
+            report_printer.instance_variable_get(:@pending_examples)
+          }
+      end
+    end
+  end
+
+  describe '#summary_output' do
+    context 'when bailed out' do
+      it 'outputs nothing' do
+        report_printer.instance_variable_set(:@bailed_out, true)
+        report_printer.summary_output(OpenStruct.new, nil)
+
+        expect(report_output.string).to be_empty
+      end
+    end
+
+    context 'when not bailed out' do
+      let(:seed) { 1 + SecureRandom.random_number(10_000) }
+      let(:tests) { 5 + SecureRandom.random_number(6) }
+      let(:examples) { Array.new(tests).map { "example-#{SecureRandom.hex}" } }
+      let(:failed) { 2 }
+      let(:failed_examples) { examples.sample(2) }
+      let(:pending) { 2 }
+      let(:pending_examples) { (examples - failed_examples).sample(2) }
+      let(:passed) { tests - failed - pending }
+      let(:duration) { SecureRandom.random_number.round(6) }
+      let(:notification) do
+        OpenStruct.new(
+          examples: examples,
+          failed_examples: failed_examples,
+          pending_examples: pending_examples,
+          duration: duration
+        )
+      end
+
+      let(:failed_examples_summary) do
+        <<-FAILURES.gsub(/^\s+\|/, '').chomp
+          |Failure:
+          |
+          |  1) sample spec fails
+          |     Failure/Error: expect(1).to eq(2)
+          |
+          |       expected: 2
+          |            got: 1
+          |
+          |       (compared using ==)
+          |     # ./spec/rspec/string_spec.rb:13
+          |  2) sample spec fails twice
+          |     Got 2 failures:
+          |
+          |     2.1) Failure/Error: expect(1).to eq(2)
+          |
+          |            expected: 2
+          |                 got: 1
+          |
+          |            (compared using ==)
+          |          # ./spec/rspec/string_spec.rb:23
+          |
+          |     2.2) Failure/Error: expect(3).to eq(4)
+          |
+          |            expected: 4
+          |                 got: 3
+          |
+          |            (compared using ==)
+          |          # ./spec/rspec/string_spec.rb:24
+        FAILURES
+      end
+      let(:pending_examples_summary) do
+        <<-PENDING.gsub(/^\s+\|/, '').chomp
+          |Pending: (Failures listed here are expected and do not affect your suite's status)
+          |
+          |  1) sample spec without implementation succeeds
+          |     # Not yet implemented
+          |     # ./spec/rspec/string_spec.rb:8
+          |
+          |  2) sample spec with unmet expectation also succeeds
+          |     # No reason given
+          |     Failure/Error: expect(1).to eq(2)
+          |
+          |       expected: 2
+          |            got: 1
+          |
+          |       (compared using ==)
+          |     # ./spec/rspec/string_spec.rb:18
+        PENDING
+      end
+      let(:failed_and_pending_summary) do
+        "#{failed_examples_summary}\n#{pending_examples_summary}"
+      end
+      let(:output_line) do
+        <<-OUTPUT.gsub(/^\s+\|/, '').chomp
+          |1..#{tests}
+          |# tests: #{tests}, passed: #{passed}, failed: #{failed}, pending: #{pending}
+          |# duration: #{duration} seconds
+          |# seed: #{seed}
+        OUTPUT
+      end
+
+      before do
+        report_printer.instance_variable_set(
+          :@failed_examples,
+          failed_examples_summary
+        )
+
+        report_printer.instance_variable_set(
+          :@pending_examples,
+          pending_examples_summary
+        )
+      end
+
+      context 'when writing to file' do
+        include_context('when writing to file')
+
+        it 'outputs tests stats to file' do
+          report_printer.summary_output(notification, seed)
+
+          expect(report_output.string.chomp).to eq(output_line)
+        end
+
+        it 'outputs failed and pending examples to stdout' do
+          expect { report_printer.summary_output(notification, seed) }
+            .to output(failed_and_pending_summary + "\n").to_stdout
+        end
+      end
+
+      context 'when not writing to file' do
+        include_context('when not writing to file')
+
+        it 'outputs tests stats, failed and pending examples' do
+          report_printer.summary_output(notification, seed)
+
+          expect(report_output.string.chomp)
+            .to eq("#{output_line}\n#{failed_and_pending_summary}")
+        end
+      end
+    end
+  end
+end