seeing_is_believing 3.0.0.beta.4 → 3.0.0.beta.5

data/spec/debugger_spec.rb

@@ -38,4 +38,8 @@ RSpec.describe SeeingIsBelieving::Debugger do
       described_class.new.context('C') { fail }
     end
   end
+
+  specify '::Null is a disabled debugger' do
+    expect(described_class::Null).to_not be_enabled
+  end
 end

data/spec/evaluate_by_moving_files_spec.rb

@@ -2,6 +2,7 @@
 
 require 'spec_helper'
 require 'seeing_is_believing/evaluate_by_moving_files'
+require 'seeing_is_believing/event_stream/handlers/update_result'
 require 'fileutils'
 
 RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
@@ -14,10 +15,17 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
     'seeing_is_believing/the_matrix'
   end
 
+  def null_options(overrides={})
+    { event_handler: lambda { |*| } }
+  end
+
   def invoke(program, options={})
+    result = SeeingIsBelieving::Result.new
+    options[:event_handler] ||= SeeingIsBelieving::EventStream::Handlers::UpdateResult.new(result)
     evaluator = described_class.new(program, filename, options)
-    FileUtils.rm_f evaluator.temp_filename
+    FileUtils.rm_f evaluator.backup_filename
     evaluator.call
+    result
   end
 
   it 'evaluates the code when the file DNE' do
@@ -31,8 +39,8 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
   end
 
   it 'raises an error when the temp file already exists' do
-    evaluator = described_class.new('', filename)
-    FileUtils.touch evaluator.temp_filename
+    evaluator = described_class.new('', filename, null_options)
+    FileUtils.touch evaluator.backup_filename
     expect { evaluator.call }.to raise_error SeeingIsBelieving::TempFileAlreadyExists
   end
 
@@ -47,29 +55,29 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
   end
 
   it 'uses HardCoreEnsure to move the file back' do
-    evaluator = described_class.new 'PROGRAM', filename
+    evaluator = described_class.new 'PROGRAM', filename, null_options
     File.open(filename, 'w') { |f| f.write 'ORIGINAL' }
-    FileUtils.rm_rf evaluator.temp_filename
+    FileUtils.rm_rf evaluator.backup_filename
     expect(SeeingIsBelieving::HardCoreEnsure).to receive(:call) do |options|
       # initial state
-      expect(File.exist? evaluator.temp_filename).to eq false
+      expect(File.exist? evaluator.backup_filename).to eq false
       expect(File.read filename).to eq 'ORIGINAL'
 
       # after code
       options[:code].call rescue nil
-      expect(File.read evaluator.temp_filename).to eq 'ORIGINAL'
+      expect(File.read evaluator.backup_filename).to eq 'ORIGINAL'
       expect(File.read filename).to eq 'PROGRAM'
 
       # after ensure
       options[:ensure].call
       expect(File.read filename).to eq 'ORIGINAL'
-      expect(File.exist? evaluator.temp_filename).to eq false
+      expect(File.exist? evaluator.backup_filename).to eq false
     end
     evaluator.call
   end
 
   it 'uses HardCoreEnsure to delete the file if it wrote it where one did not previously exist' do
-    evaluator = described_class.new 'PROGRAM', filename
+    evaluator = described_class.new 'PROGRAM', filename, null_options
     FileUtils.rm_rf filename
     expect(SeeingIsBelieving::HardCoreEnsure).to receive(:call) do |options|
       # initial state
@@ -91,13 +99,13 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
     other_filename2 = File.join filedir, 'other2.rb'
     File.open(other_filename1, 'w') { |f| f.puts "puts 123" }
     File.open(other_filename2, 'w') { |f| f.puts "puts 456" }
-    result = invoke '', require: [matrix_file, other_filename1, other_filename2]
+    result = invoke '', require_files: [matrix_file, other_filename1, other_filename2]
     expect(result.stdout).to eq "123\n456\n"
   end
 
   it 'can set the load path' do
     File.open(File.join(filedir, 'other1.rb'), 'w') { |f| f.puts "puts 123" }
-    result = invoke '', require: [matrix_file, 'other1'], load_path: [filedir]
+    result = invoke '', require_files: [matrix_file, 'other1'], load_path_dirs: [filedir]
     expect(result.stdout).to eq "123\n"
   end
 
@@ -111,16 +119,26 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
     end
   end
 
-  it 'if it fails, it tells the debugger some information and raises an error' do
-    error_stream = StringIO.new
-    evaluator = described_class.new 'raise "omg"', filename, debugger: SeeingIsBelieving::Debugger.new(stream: error_stream)
-    expect(evaluator).to receive(:evaluate_file).and_raise("whatevz")
-    FileUtils.rm_f evaluator.temp_filename
-    expect { evaluator.call }.to raise_error SeeingIsBelieving::BugInSib
-    expect(error_stream.string).to include "Program could not be evaluated"
-  end
-
   it 'does not blow up on exceptions raised in at_exit blocks' do
     expect { invoke 'at_exit { raise "zomg" }' }.to_not raise_error
   end
+
+  it 'can provide stdin as a string or stream' do
+    expect(invoke('p gets', provided_input: 'a').stdout).to eq %("a"\n)
+    require 'stringio'
+    result = invoke 'p gets', provided_input: StringIO.new('b')
+    expect(result.stdout).to eq %("b"\n)
+  end
+
+  it 'can set a timeout' do
+    expect(Timeout).to receive(:timeout).with(123).and_raise(Timeout::Error)
+    expect(Process).to receive(:kill)
+    expect { expect(invoke('p gets', timeout_seconds: 123).stdout).to eq %("a"\n) }
+      .to raise_error Timeout::Error
+  end
+
+  it 'raises an ArgumentError if given arguments it doesn\'t know' do
+    expect { invoke '1', watisthis: :idontknow }
+      .to raise_error ArgumentError, /watisthis/
+  end
 end

data/spec/event_stream_spec.rb

@@ -2,6 +2,8 @@
 
 require 'seeing_is_believing/event_stream/producer'
 require 'seeing_is_believing/event_stream/consumer'
+require 'seeing_is_believing/event_stream/handlers/debug'
+require 'seeing_is_believing/debugger'
 
 module SeeingIsBelieving::EventStream
   RSpec.describe SeeingIsBelieving::EventStream do
@@ -16,6 +18,7 @@ module SeeingIsBelieving::EventStream
 
     def finish!
       producer.finish!
+      consumer.process_exitstatus(0)
       close_streams eventstream_producer, stdout_producer, stderr_producer
     end
 
@@ -77,49 +80,88 @@ module SeeingIsBelieving::EventStream
         expect(producer_threads).to be_none(&:alive?)
       end
 
-      it 'raises NoMoreInput if input is closed before it finishes reading the number of requested inputs' do
+      it 'transcodes any received messages to UTF8' do
+        utf8  = "こんにちは" # from https://github.com/svenfuchs/i18n/blob/ee7fef8e9b9ee2f7d16e6c36d669ee7fb24ec613/lib/i18n/tests/interpolation.rb#L72
+        eucjp = utf8.encode(Encoding::EUCJP)
+        producer.record_sib_version(eucjp)
+        version = consumer.call.value
+        expect(version).to eq utf8
+        expect(version).to_not eq eucjp          # general sanity checks to make
+        expect(utf8.bytes).to_not eq eucjp.bytes # sure I don't accidentally pass
+      end
+
+      def ascii8bit(str)
+        str.force_encoding Encoding::ASCII_8BIT
+      end
+
+      it 'force encodes the message to UTF8 when it can\'t validly transcode' do
+        producer.record_sib_version(ascii8bit("åß∂ƒ"))
+        version = consumer.call.value
+        expect(version).to eq "åß∂ƒ"
+        expect(version).to_not eq ascii8bit("åß∂ƒ")
+      end
+
+      it 'scrubs any invalid bytes to "�" when the force encoding isn\'t valid' do
+        producer.record_sib_version(ascii8bit "a\xFF å")  # unicode bytes can't begin with
+        expect(consumer.call.value).to eq "a� å"          # space just so its easier to see
+      end
+
+      it 'raises NoMoreEvents if input is closed before it finishes reading the number of requested inputs' do
         finish!
-        expect { consumer.call 10 }.to raise_error SeeingIsBelieving::EventStream::Consumer::NoMoreInput
+        expect { consumer.call 10 }.to raise_error SeeingIsBelieving::NoMoreEvents
       end
 
-      it 'raises NoMoreInput once it its input streams are all closed' do
-        producer.finish!
+      it 'raises NoMoreEvents once it its input streams are all closed and its seen the exit status' do
         close_streams eventstream_producer, stdout_producer, stderr_producer
-        consumer.call 2
-        expect { consumer.call }.to raise_error SeeingIsBelieving::EventStream::Consumer::NoMoreInput
+        producer.finish!
+        consumer.process_exitstatus 0
+        consumer.each { }
+        expect { consumer.call }.to raise_error SeeingIsBelieving::NoMoreEvents
       end
 
-      it 'raises NoMoreInput if its end of the stream is closed and there is no more stdout/stderr' do
-        close_streams eventstream_consumer, stdout_producer, stderr_producer
-        expect { consumer.call }.to raise_error SeeingIsBelieving::EventStream::Consumer::WtfWhoClosedMyShit
-        expect { consumer.call }.to raise_error SeeingIsBelieving::EventStream::Consumer::NoMoreInput
+      it 'gracefully handles its side of the streams getting closed' do
+        close_streams eventstream_consumer, stdout_consumer, stderr_consumer
+        consumer.process_exitstatus 0
+        consumer.each { }
+        expect { consumer.call }.to raise_error SeeingIsBelieving::NoMoreEvents
       end
 
-      it 'raises WtfWhoClosedMyShit if its end of the stream is closed' do
-        close_streams eventstream_consumer, stdout_producer, stderr_producer
-        expect { consumer.call }.to raise_error SeeingIsBelieving::EventStream::Consumer::WtfWhoClosedMyShit
+      specify 'if an incomprehensible event is received, it raises an UnknownEvent' do
+        eventstream_producer.puts "this is nonsense!"
+        expect{ consumer.call }.to raise_error SeeingIsBelieving::UnknownEvent, /nonsense/
       end
     end
 
     describe 'each' do
       it 'loops through and yields all events' do
+        # declare 2 events
         producer.record_result :inspect, 100, 2
+        producer.record_sib_version('some ver')
+
+        # close streams so that it won't block waiting for more events
         finish!
 
+        # record events
         events = []
         consumer.each { |e| events << e }
-        line_result  = events.find { |e| e.kind_of? Events::LineResult }
-        exitstatus   = events.find { |e| e.kind_of? Events::Exitstatus }
+
+        # it yielded the line result
+        line_result = events.find { |e| e.kind_of? Events::LineResult }
         expect(line_result.line_number).to eq 100
-        expect(exitstatus.value).to eq 0
+
+        # it yielded the version
+        version = events.find { |e| e.kind_of? Events::SiBVersion }
+        expect(version.value).to eq 'some ver'
       end
 
       it 'stops looping if there is no more input' do
+        producer.record_result :inspect, 100, 2
+        producer.record_sib_version('some ver')
         finish!
-        expect(consumer.each.map { |e| e }).to eq [
-          Events::NumLines.new(0),
-          Events::Exitstatus.new(0),
-        ]
+        expect(consumer.each.map { |e| e.class }.sort_by(&:to_s))
+          .to eq [ Events::EventStreamClosed, Events::Exitstatus,   Events::Finished,
+                   Events::LineResult,        Events::SiBVersion, Events::StderrClosed, Events::StdoutClosed,
+                 ]
       end
 
       it 'returns nil' do
@@ -128,8 +170,10 @@ module SeeingIsBelieving::EventStream
       end
 
       it 'returns an enumerator if not given a block' do
+        producer.record_sib_version('some ver')
         finish!
-        expect(consumer.each.map &:class).to include Events::Exitstatus
+        classes = consumer.each.map &:class
+        expect(classes).to include Events::SiBVersion
       end
     end
 
@@ -147,15 +191,15 @@ module SeeingIsBelieving::EventStream
         producer.record_result :type1, 123, "Ω≈ç√∫˜µ≤≥"
 
         expect(consumer.call 9).to eq [
-          Events::LineResult.new(:type1, 123, [*'a'..'z', *'A'..'Z', *'0'..'9'].join("").inspect),
-          Events::LineResult.new(:type1, 123, '"'.inspect),
-          Events::LineResult.new(:type1, 123, '""'.inspect),
-          Events::LineResult.new(:type1, 123, "\n".inspect),
-          Events::LineResult.new(:type1, 123, "\r".inspect),
-          Events::LineResult.new(:type1, 123, "\n\r\n".inspect),
-          Events::LineResult.new(:type1, 123, "\#{}".inspect),
-          Events::LineResult.new(:type1, 123, [*0..127].map(&:chr).join("").inspect),
-          Events::LineResult.new(:type1, 123, "Ω≈ç√∫˜µ≤≥".inspect),
+          Events::LineResult.new(type: :type1, line_number: 123, inspected: [*'a'..'z', *'A'..'Z', *'0'..'9'].join("").inspect),
+          Events::LineResult.new(type: :type1, line_number: 123, inspected: '"'.inspect),
+          Events::LineResult.new(type: :type1, line_number: 123, inspected: '""'.inspect),
+          Events::LineResult.new(type: :type1, line_number: 123, inspected: "\n".inspect),
+          Events::LineResult.new(type: :type1, line_number: 123, inspected: "\r".inspect),
+          Events::LineResult.new(type: :type1, line_number: 123, inspected: "\n\r\n".inspect),
+          Events::LineResult.new(type: :type1, line_number: 123, inspected: "\#{}".inspect),
+          Events::LineResult.new(type: :type1, line_number: 123, inspected: [*0..127].map(&:chr).join("").inspect),
+          Events::LineResult.new(type: :type1, line_number: 123, inspected: "Ω≈ç√∫˜µ≤≥".inspect),
         ]
       end
 
@@ -163,16 +207,16 @@ module SeeingIsBelieving::EventStream
         producer.max_line_captures = 2
 
         producer.record_result :type1, 123, 1
-        expect(consumer.call 1).to eq Events::LineResult.new(:type1, 123, '1')
+        expect(consumer.call 1).to eq Events::LineResult.new(type: :type1, line_number: 123, inspected: '1')
 
         producer.record_result :type1, 123, 2
-        expect(consumer.call 1).to eq Events::LineResult.new(:type1, 123, '2')
+        expect(consumer.call 1).to eq Events::LineResult.new(type: :type1, line_number: 123, inspected: '2')
 
         producer.record_result :type1, 123, 3
         producer.record_result :type1, 123, 4
         producer.record_result :type2, 123, 1
-        expect(consumer.call 2).to eq [Events::UnrecordedResult.new(:type1, 123),
-                                       Events::LineResult.new(:type2, 123, '1')]
+        expect(consumer.call 2).to eq [Events::ResultsTruncated.new(type: :type1, line_number: 123),
+                                       Events::LineResult.new(type: :type2, line_number: 123, inspected: '1')]
       end
 
       it 'scopes the max to a given type/line' do
@@ -185,12 +229,12 @@ module SeeingIsBelieving::EventStream
         producer.record_result :type2, 1, 5
         producer.record_result :type2, 1, 6
         expect(consumer.call 6).to eq [
-          Events::LineResult.new(:type1, 1, '1'),
-          Events::UnrecordedResult.new(:type1, 1),
-          Events::LineResult.new(:type1, 2, '3'),
-          Events::UnrecordedResult.new(:type1, 2),
-          Events::LineResult.new(:type2, 1, '5'),
-          Events::UnrecordedResult.new(:type2, 1),
+          Events::LineResult.new(      type: :type1, line_number: 1, inspected: '1'),
+          Events::ResultsTruncated.new(type: :type1, line_number: 1),
+          Events::LineResult.new(      type: :type1, line_number: 2, inspected: '3'),
+          Events::ResultsTruncated.new(type: :type1, line_number: 2),
+          Events::LineResult.new(      type: :type2, line_number: 1, inspected: '5'),
+          Events::ResultsTruncated.new(type: :type2, line_number: 1),
         ]
       end
 
@@ -202,10 +246,10 @@ module SeeingIsBelieving::EventStream
       # Some examples, mostly for the purpose of running individually if things get confusing
       example 'Example: Simple' do
         producer.record_result :type, 1, "a"
-        expect(consumer.call).to eq Events::LineResult.new(:type, 1, '"a"')
+        expect(consumer.call).to eq Events::LineResult.new(type: :type, line_number: 1, inspected: '"a"')
 
         producer.record_result :type, 1, 1
-        expect(consumer.call).to eq Events::LineResult.new(:type, 1, '1')
+        expect(consumer.call).to eq Events::LineResult.new(type: :type, line_number: 1, inspected: '1')
       end
 
       example 'Example: Complex' do
@@ -213,14 +257,14 @@ module SeeingIsBelieving::EventStream
         str2 = str1.dup
         producer.record_result :type, 1, str2
         expect(str2).to eq str1 # just making sure it doesn't mutate since this one is so complex
-        expect(consumer.call).to eq Events::LineResult.new(:type, 1, str1.inspect)
+        expect(consumer.call).to eq Events::LineResult.new(type: :type, line_number: 1, inspected: str1.inspect)
       end
 
       context 'calls #inspect when no block is given' do
         it "doesn't blow up when there is no #inspect available e.g. BasicObject" do
           obj = BasicObject.new
           producer.record_result :type, 1, obj
-          expect(consumer.call).to eq Events::LineResult.new(:type, 1, "#<no inspect available>")
+          expect(consumer.call).to eq Events::LineResult.new(type: :type, line_number: 1, inspected: "#<no inspect available>")
         end
 
 
@@ -230,7 +274,7 @@ module SeeingIsBelieving::EventStream
             nil
           end
           producer.record_result :type, 1, obj
-          expect(consumer.call).to eq Events::LineResult.new(:type, 1, "#<no inspect available>")
+          expect(consumer.call).to eq Events::LineResult.new(type: :type, line_number: 1, inspected: "#<no inspect available>")
         end
 
         it 'only calls inspect once' do
@@ -250,24 +294,24 @@ module SeeingIsBelieving::EventStream
           def o.inspect()       'real-inspect'  end
           def o.other_inspect() 'other-inspect' end
           producer.record_result(:type, 1, o) { |x| x.other_inspect }
-          expect(consumer.call).to eq Events::LineResult.new(:type, 1, 'other-inspect')
+          expect(consumer.call).to eq Events::LineResult.new(type: :type, line_number: 1, inspected: 'other-inspect')
         end
 
         it 'doesn\'t blow up if the block raises' do
           o = Object.new
           producer.record_result(:type, 1, o) { raise Exception, "zomg" }
-          expect(consumer.call).to eq Events::LineResult.new(:type, 1, '#<no inspect available>')
+          expect(consumer.call).to eq Events::LineResult.new(type: :type, line_number: 1, inspected: '#<no inspect available>')
         end
 
         it 'doesn\'t blow up if the block returns a non-string' do
           o = Object.new
           producer.record_result(:type, 1, o) { nil }
-          expect(consumer.call).to eq Events::LineResult.new(:type, 1, '#<no inspect available>')
+          expect(consumer.call).to eq Events::LineResult.new(type: :type, line_number: 1, inspected: '#<no inspect available>')
 
           stringish = Object.new
           def stringish.to_str() 'actual string' end
           producer.record_result(:type, 1, o) { stringish }
-          expect(consumer.call).to eq Events::LineResult.new(:type, 1, 'actual string')
+          expect(consumer.call).to eq Events::LineResult.new(type: :type, line_number: 1, inspected: 'actual string')
         end
 
         it 'invokes the block only once' do
@@ -291,17 +335,17 @@ module SeeingIsBelieving::EventStream
       it 'emits the event and sets the max_line_captures' do
         producer.record_max_line_captures 123
         expect(producer.max_line_captures).to eq 123
-        expect(consumer.call).to eq Events::MaxLineCaptures.new(123)
+        expect(consumer.call).to eq Events::MaxLineCaptures.new(value: 123)
       end
 
       it 'interprets numbers' do
         producer.record_max_line_captures 12
-        expect(consumer.call).to eq Events::MaxLineCaptures.new(12)
+        expect(consumer.call).to eq Events::MaxLineCaptures.new(value: 12)
       end
 
       it 'interprets infinity' do
         producer.record_max_line_captures Float::INFINITY
-        expect(consumer.call).to eq Events::MaxLineCaptures.new(Float::INFINITY)
+        expect(consumer.call).to eq Events::MaxLineCaptures.new(value: Float::INFINITY)
       end
     end
 
@@ -352,23 +396,17 @@ module SeeingIsBelieving::EventStream
       end
 
       context 'when the exception is a SystemExit' do
-        it 'sets the exit status to the one provided' do
-          record_exception { exit 22 }
-          expect(producer.exitstatus).to eq 22
-        end
-
-        it 'sets the exit status to 0 or 1 if exited with true or false' do
-          expect(producer.exitstatus).to eq 0
-          record_exception { exit true }
-          expect(producer.exitstatus).to eq 0
-          record_exception { exit false }
-          expect(producer.exitstatus).to eq 1
-        end
+        it 'returns the status and does not record the exception' do
+          exception = nil
+          begin exit 22
+          rescue SystemExit
+            exception = $!
+          end
 
-        it 'sets the exit status to 1 if the exception is not a SystemExit' do
-          expect(producer.exitstatus).to eq 0
-          record_exception { raise }
-          expect(producer.exitstatus).to eq 1
+          exitstatus = producer.record_exception(1, exception)
+          expect(exitstatus).to eq 22
+          finish!
+          expect(consumer.each.find { |e| e.kind_of? Events::Exception }).to eq nil
         end
       end
 
@@ -426,7 +464,7 @@ module SeeingIsBelieving::EventStream
       describe 'recording the version' do
         it 'emits the version info' do
           producer.record_sib_version '1.2.3'
-          expect(consumer.call).to eq Events::SiBVersion.new("1.2.3")
+          expect(consumer.call).to eq Events::SiBVersion.new(value: "1.2.3")
         end
       end
 
@@ -440,7 +478,7 @@ module SeeingIsBelieving::EventStream
     describe 'record_ruby_version' do
       it 'emits the ruby version info' do
         producer.record_ruby_version 'o.m.g.'
-        expect(consumer.call).to eq Events::RubyVersion.new('o.m.g.')
+        expect(consumer.call).to eq Events::RubyVersion.new(value: 'o.m.g.')
       end
     end
 
@@ -451,96 +489,207 @@ module SeeingIsBelieving::EventStream
       end
       it 'emits the filename' do
         producer.record_filename 'this-iz-mah-file.rb'
-        expect(consumer.call).to eq Events::Filename.new('this-iz-mah-file.rb')
+        expect(consumer.call).to eq Events::Filename.new(value: 'this-iz-mah-file.rb')
       end
     end
 
     describe 'stdout' do
       it 'is emitted along with the events from the event stream' do
         stdout_producer.puts "this is the stdout¡"
-        expect(consumer.call).to eq Events::Stdout.new("this is the stdout¡\n")
+        expect(consumer.call).to eq Events::Stdout.new(value: "this is the stdout¡\n")
       end
       specify 'each line is emitted as an event' do
         stdout_producer.puts "first"
         stdout_producer.puts "second\nthird"
-        expect(consumer.call).to eq Events::Stdout.new("first\n")
-        expect(consumer.call).to eq Events::Stdout.new("second\n")
-        expect(consumer.call).to eq Events::Stdout.new("third\n")
+        expect(consumer.call).to eq Events::Stdout.new(value: "first\n")
+        expect(consumer.call).to eq Events::Stdout.new(value: "second\n")
+        expect(consumer.call).to eq Events::Stdout.new(value: "third\n")
       end
     end
 
     describe 'stderr' do
       it 'is emitted along with the events from the event stream' do
         stderr_producer.puts "this is the stderr¡"
-        expect(consumer.call).to eq Events::Stderr.new("this is the stderr¡\n")
+        expect(consumer.call).to eq Events::Stderr.new(value: "this is the stderr¡\n")
       end
       specify 'each line is emitted as an event' do
         stderr_producer.puts "first"
         stderr_producer.puts "second\nthird"
-        expect(consumer.call).to eq Events::Stderr.new("first\n")
-        expect(consumer.call).to eq Events::Stderr.new("second\n")
-        expect(consumer.call).to eq Events::Stderr.new("third\n")
+        expect(consumer.call).to eq Events::Stderr.new(value: "first\n")
+        expect(consumer.call).to eq Events::Stderr.new(value: "second\n")
+        expect(consumer.call).to eq Events::Stderr.new(value: "third\n")
       end
     end
 
+    describe 'record_exec' do
+      it 'records the event and the inspection of the args that were given to exec' do
+        producer.record_exec(["ls", "-l"])
+        expect(consumer.call).to eq Events::Exec.new(args: '["ls", "-l"]')
+      end
+    end
 
-    describe 'finish!' do
-      def final_event(producer, consumer, event_class)
-        finish!
-        consumer.call(2).find { |e| e.class == event_class }
+    describe 'record_num_lines' do
+      it 'interprets numbers' do
+        producer.record_num_lines 21
+        expect(consumer.call).to eq Events::NumLines.new(value: 21)
       end
+    end
 
+    describe 'finish!' do
       it 'stops the producer from producing' do
         read, write = IO.pipe
         producer = SeeingIsBelieving::EventStream::Producer.new write
         producer.finish!
-        read.gets
-        read.gets
         producer.record_filename("zomg")
         write.close
         expect(read.gets).to eq nil
       end
+    end
 
-      describe 'num_lines' do
-        it 'interprets numbers' do
-          producer.num_lines = 21
-          expect(final_event(producer, consumer, Events::NumLines).value).to eq 21
-        end
+    describe 'final events' do
+      it 'emits a StdoutClosed event when consumer side of stdout closes' do
+        stdout_consumer.close
+        expect(consumer.call).to eq Events::StdoutClosed.new(side: :consumer)
+      end
+      it 'emits a StdoutClosed event when producer side of stdout closes' do
+        stdout_producer.close
+        expect(consumer.call).to eq Events::StdoutClosed.new(side: :producer)
+      end
 
-        it 'is 0 by default' do
-          expect(final_event(producer, consumer, Events::NumLines).value).to eq 0
-        end
+      it 'emits a StderrClosed event when consumer side of stderr closes' do
+        stderr_consumer.close
+        expect(consumer.call).to eq Events::StderrClosed.new(side: :consumer)
+      end
+      it 'emits a StderrClosed event when producer side of stderr closes' do
+        stderr_producer.close
+        expect(consumer.call).to eq Events::StderrClosed.new(side: :producer)
+      end
 
-        it 'updates its value if it sees a result from a line larger than its value' do
-          producer.num_lines = 2
-          producer.record_result :sometype, 100, :someval
-          expect(final_event(producer, consumer, Events::NumLines).value).to eq 100
-        end
+      it 'emits a EventStreamClosed event when consumer side of event_stream closes' do
+        eventstream_consumer.close
+        expect(consumer.call).to eq Events::EventStreamClosed.new(side: :consumer)
+      end
+      it 'emits a EventStreamClosed event when producer side of event_stream closes' do
+        eventstream_producer.close
+        expect(consumer.call).to eq Events::EventStreamClosed.new(side: :producer)
+      end
 
-        it 'updates its value if it sees an exception from a line larger than its value' do
-          producer.num_lines = 2
-          begin; raise; rescue; e = $!; end
-          producer.record_exception 100, e
-          expect(final_event(producer, consumer, Events::NumLines).value).to eq 100
-        end
+      it 'emits a Exitstatus event on process_exitstatus' do
+        consumer.process_exitstatus 92
+        expect(consumer.call).to eq Events::Exitstatus.new(value: 92)
       end
 
-      describe 'exitstatus' do
-        it 'is 0 by default' do
-          expect(final_event(producer, consumer, Events::Exitstatus).value).to eq 0
-        end
+      it 'emits a Finished event when all streams are closed and it has the exit status' do
+        finish!
+        event_classes = consumer.each.map(&:class)
+        expect(event_classes).to include Events::Finished
+      end
+    end
 
-        it 'can be overridden' do
-          producer.exitstatus = 74
-          expect(final_event(producer, consumer, Events::Exitstatus).value).to eq 74
-        end
+    describe Events do
+      specify 'Event raises an error if .event_name was not overridden' do
+        expect { Event.event_name }.to raise_error NotImplementedError
+      end
+      specify 'all events have a reasonable event name' do
+        pairs = [
+          [Events::Stdout           , :stdout],
+          [Events::Stderr           , :stderr],
+          [Events::MaxLineCaptures  , :max_line_captures],
+          [Events::Filename         , :filename],
+          [Events::NumLines         , :num_lines],
+          [Events::SiBVersion       , :sib_version],
+          [Events::RubyVersion      , :ruby_version],
+          [Events::Exitstatus       , :exitstatus],
+          [Events::Exec             , :exec],
+          [Events::ResultsTruncated , :results_truncated],
+          [Events::LineResult       , :line_result],
+          [Events::Exception        , :exception],
+          [Events::StdoutClosed     , :stdout_closed],
+          [Events::StderrClosed     , :stderr_closed],
+          [Events::EventStreamClosed, :event_stream_closed],
+          [Events::Finished         , :finished],
+        ]
+        pairs.each { |klass, name| expect(klass.event_name).to eq name }
+
+        events_we_tested = pairs.map(&:first).flatten
+        event_classes = Events.constants.map { |name| Events.const_get name }
+        expect(event_classes - events_we_tested).to eq []
+      end
+      specify 'their event_name and attributes are included in their as_json' do
+        expect(Events::Stdout.new(value: "abc").as_json).to eq [:stdout, {value: "abc"}]
+      end
+      specify 'MaxLineCaptures#as_json includes is_infinity, and sets value to -1 in this case' do
+        expect(Events::MaxLineCaptures.new(value: Float::INFINITY).as_json).to eq [:max_line_captures, {value: -1, is_infinity: true}]
+        expect(Events::MaxLineCaptures.new(value: 123).as_json).to eq [:max_line_captures, {value: 123, is_infinity: false}]
+      end
+    end
+
+    require 'seeing_is_believing/event_stream/handlers/stream_json_events'
+    describe Handlers::StreamJsonEvents do
+      it 'writes each event\'s json representation to the stream' do
+        stream  = ""
+        handler = described_class.new stream
+
+        handler.call Events::Stdout.new(value: "abc")
+        expect(stream).to eq %'["stdout",{"value":"abc"}]\n'
+
+        handler.call Events::Finished.new
+        expect(stream).to eq %'["stdout",{"value":"abc"}]\n'+
+                             %'["finished",{}]\n'
+      end
+
+      it 'calls flush after each event, when the stream responds to it' do
+        stream = object_spy $stdout
+        flushcount = 0
+        allow(stream).to receive(:flush) { flushcount += 1 }
+
+        handler = described_class.new stream
+        expect(flushcount).to eq 0
+
+        handler.call Events::Stdout.new(value: "abc")
+        expect(flushcount).to eq 1
+
+        handler.call Events::Finished.new
+        expect(flushcount).to eq 2
       end
     end
 
-    specify 'if an incomprehensible event is received, it raises an UnknownEvent' do
-      eventstream_producer.puts "this is nonsense!"
-      eventstream_producer.close
-      expect{ consumer.call }.to raise_error SeeingIsBelieving::EventStream::Consumer::UnknownEvent, /nonsense/
+    describe Handlers::Debug do
+      let(:stream)          { "" }
+      let(:events_seen)     { [] }
+      let(:debugger)        { SeeingIsBelieving::Debugger.new stream: stream }
+      let(:parent_observer) { lambda { |event| events_seen << event } }
+      let(:debug_handler)   { described_class.new(debugger, parent_observer) }
+
+      it 'passes events through to the parent observer' do
+        event = Events::Stdout.new(value: "zomg")
+        debug_handler.call(event)
+        expect(events_seen).to eq [event]
+      end
+
+      it 'generally prints things, prettily, wide and short' do
+        [ Events::Stdout.new(value: "short"),
+          Events::Stdout.new(value: "long"*1000),
+          Events::Exec.new(args: ["a", "b", "c"]),
+          Events::StdoutClosed.new(side: :consumer),
+          Events::Exception.new(line_number: 100,
+                                class_name:  "SomethingException",
+                                message:     "The things, they blew up!",
+                                backtrace:   ["a"*10,"b"*2000]),
+          Events::Finished.new,
+        ].each { |event| debug_handler.call event }
+
+        expect(stream).to match /^Stdout\b/   # the events al made it
+        expect(stream).to match /^Exec\b/
+        expect(stream).to match /^StdoutClosed\b/
+        expect(stream).to match /^Exception\b/
+        expect(stream).to match /^Finished\b/
+        expect(stream).to match /^\| - a+/    # a backtrace in there
+        expect(stream).to match /\.{3}$/      # truncation indication
+        stream.each_line do |line|
+          expect(line.length).to be <= 151    # long lines got truncated (151 b/c newline is counted)
+        end
+      end
     end
   end
 end