seeing_is_believing 3.0.0.beta.3 → 3.0.0.beta.4

data/lib/seeing_is_believing/event_stream/events.rb

@@ -6,10 +6,12 @@ class SeeingIsBelieving
       Stdout           = Struct.new(:value)
       Stderr           = Struct.new(:value)
       MaxLineCaptures  = Struct.new(:value)
+      Filename         = Struct.new(:value)
       NumLines         = Struct.new(:value)
+      SiBVersion       = Struct.new(:value)
+      RubyVersion      = Struct.new(:value)
       Exitstatus       = Struct.new(:value)
       Exception        = Struct.new(:line_number, :class_name, :message, :backtrace)
-      Finish           = Class.new
     end
   end
 end

data/lib/seeing_is_believing/event_stream/producer.rb

@@ -1,8 +1,16 @@
 require 'seeing_is_believing/event_stream/events'
+require 'thread'
+
 class SeeingIsBelieving
   module EventStream
-    require 'thread'
     class Producer
+
+      module NullQueue
+        extend self
+        def <<(*)   end
+        def shift() end
+      end
+
       attr_accessor :exitstatus, :max_line_captures, :num_lines, :filename
 
       def initialize(resultstream)
@@ -11,31 +19,38 @@ class SeeingIsBelieving
         self.max_line_captures = Float::INFINITY
         self.num_lines         = 0
         self.recorded_results  = []
-        self.queue             = Thread::Queue.new
+        self.queue             = Queue.new
         self.producer_thread   = Thread.new do
-          finish = "finish"
           begin
             resultstream.sync = true
             loop do
               to_publish = queue.shift
-              if to_publish == finish
-                resultstream << "finish\n"
-                break
-              else
-                resultstream << (to_publish << "\n")
-              end
+              break if to_publish == :break
+              resultstream << (to_publish << "\n")
             end
           rescue IOError, Errno::EPIPE
-            loop { break if queue.shift == finish }
+            queue.clear
           ensure
             resultstream.flush rescue nil
           end
+          self.queue = NullQueue
         end
       end
 
-      # for a consideration of many different ways of doing this, see 5633064
-      def to_string_token(string)
-        [Marshal.dump(string.to_s)].pack('m0')
+      attr_reader :version
+      alias ver version
+      def record_sib_version(sib_version)
+        @version = sib_version
+        queue << "sib_version #{to_string_token sib_version}"
+      end
+
+      def record_ruby_version(ruby_version)
+        queue << "ruby_version #{to_string_token ruby_version}"
+      end
+
+      def record_max_line_captures(max_line_captures)
+        self.max_line_captures = max_line_captures
+        queue << "max_line_captures #{max_line_captures}"
       end
 
       StackErrors = [SystemStackError]
@@ -89,25 +104,27 @@ class SeeingIsBelieving
         queue << "end"
       end
 
-      def record_stdout(stdout)
-        queue << "stdout #{to_string_token stdout}"
-      end
-
-      def record_stderr(stderr)
-        queue << "stderr #{to_string_token stderr}"
+      def record_filename(filename)
+        self.filename = filename
+        queue << "filename #{to_string_token filename}"
       end
 
+      # note that producer will continue reading until stream is closed
       def finish!
-        queue << "max_line_captures #{max_line_captures}"
         queue << "num_lines #{num_lines}"
         queue << "exitstatus #{exitstatus}"
-        queue << "finish".freeze
+        queue << :break
         producer_thread.join
       end
 
       private
 
       attr_accessor :resultstream, :queue, :producer_thread, :recorded_results
+
+      # for a consideration of many different ways of doing this, see 5633064
+      def to_string_token(string)
+        [Marshal.dump(string.to_s)].pack('m0')
+      end
     end
   end
 end

data/lib/seeing_is_believing/event_stream/update_result.rb

@@ -1,17 +1,21 @@
 require 'seeing_is_believing/event_stream/events'
 class SeeingIsBelieving
   module EventStream
+    # Adapter between EventStream and Result
     module UpdateResult
       def self.call(result, event)
          case event
          when EventStream::Events::LineResult       then result.record_result(event.type, event.line_number, event.inspected)
          when EventStream::Events::UnrecordedResult then result.record_result(event.type, event.line_number, '...') # <-- is this really what I want?
          when EventStream::Events::Exception        then result.record_exception event.line_number, event.class_name, event.message, event.backtrace
-         when EventStream::Events::Stdout           then result.stdout             = event.value
-         when EventStream::Events::Stderr           then result.stderr             = event.value
+         when EventStream::Events::Stdout           then result.stdout            << event.value
+         when EventStream::Events::Stderr           then result.stderr            << event.value
          when EventStream::Events::MaxLineCaptures  then result.number_of_captures = event.value
          when EventStream::Events::Exitstatus       then result.exitstatus         = event.value
          when EventStream::Events::NumLines         then result.num_lines          = event.value
+         when EventStream::Events::SiBVersion       then result.sib_version        = event.value
+         when EventStream::Events::RubyVersion      then result.ruby_version       = event.value
+         when EventStream::Events::Filename         then result.filename           = event.value
          else raise "Unknown event: #{event.inspect}"
          end
       end

data/lib/seeing_is_believing/inspect_expressions.rb

@@ -7,7 +7,11 @@ class SeeingIsBelieving
       number_of_captures_as_str = 'Float::INFINITY' if number_of_captures == Float::INFINITY
 
       wrap_expressions_callbacks = {}
-      wrap_expressions_callbacks[:before_all]  = options.fetch :before_all,  -> { "$SiB.filename = #{filename.inspect}; $SiB.max_line_captures = #{number_of_captures_as_str}; $SiB.num_lines = #{program.lines.count}; " }
+      wrap_expressions_callbacks[:before_all]  = options.fetch :before_all,  -> { "$SiB.record_ruby_version RUBY_VERSION;"\
+                                                                                  "$SiB.record_sib_version #{VERSION.inspect};"\
+                                                                                  "$SiB.record_filename #{filename.inspect};"\
+                                                                                  "$SiB.record_max_line_captures #{number_of_captures_as_str};"\
+                                                                                  "$SiB.num_lines = #{program.lines.count}; " }
       wrap_expressions_callbacks[:after_all]   = options.fetch :after_all,   -> { "" }
       wrap_expressions_callbacks[:before_each] = options.fetch :before_each, -> line_number { "(" }
       wrap_expressions_callbacks[:after_each]  = options.fetch :after_each,  -> line_number { ").tap { |v| $SiB.record_result(:inspect, #{line_number}, v) }" }

data/lib/seeing_is_believing/parser_helpers.rb

@@ -1,4 +1,14 @@
-require 'parser/current'
+module Parser
+  class << self
+    # With new versioning, there's lots of small versions
+    # we don't need it to complain that we're on 2.1.1 and its parsing 2.1.5
+    # https://github.com/whitequark/parser/blob/e2249d7051b1adb6979139928e14a81bc62f566e/lib/parser/current.rb#L3
+    def warn(*) end
+    require 'parser/current'
+    remove_method :warn
+  end
+end
+
 class SeeingIsBelieving
   module ParserHelpers
 

data/lib/seeing_is_believing/result.rb

@@ -3,7 +3,12 @@ class SeeingIsBelieving
     include Enumerable
     RecordedException = Struct.new :line_number, :class_name, :message, :backtrace
 
-    attr_accessor :stdout, :stderr, :exitstatus, :number_of_captures, :exception, :num_lines
+    attr_accessor :stdout, :stderr, :exitstatus, :number_of_captures, :exception, :num_lines, :sib_version, :ruby_version, :filename
+
+    def initialize
+      self.stdout = ''
+      self.stderr = ''
+    end
 
     alias has_exception? exception
 

data/lib/seeing_is_believing/the_matrix.rb

@@ -8,28 +8,28 @@
 require_relative 'version'
 require_relative 'event_stream/producer'
 
-event_stream = STDOUT.dup  # duped Ruby object with the real file descriptor
+event_stream = IO.open(ARGV.shift.to_i, "w")
 $SiB = SeeingIsBelieving::EventStream::Producer.new(event_stream)
 
-stdout = STDOUT # keep our own ref, b/c user could mess w/ constants and globals
-read_stdout, write_stdout = IO.pipe
-stdout.reopen(write_stdout)
+stdout, stderr = STDOUT, STDERR
+finish = lambda do
+  $SiB.finish!
+  event_stream.close
+  stdout.flush
+  stderr.flush
+end
 
-stderr = STDERR
-read_stderr, write_stderr = IO.pipe
-stderr.reopen(write_stderr)
+real_exec = method :exec
+Kernel.module_eval do
+  private
+  define_method :exec do |*args, &block| # TODO: Add an event for exec?
+    finish.call
+    real_exec.call(*args, &block)
+  end
+end
 
 at_exit do
-  _, blackhole = IO.pipe
-  stdout.reopen(blackhole)
-  stderr.reopen(blackhole)
-
-  write_stdout.close unless write_stdout.closed?
-  $SiB.record_stdout read_stdout.read
-
-  write_stderr.close unless write_stderr.closed?
-  $SiB.record_stderr read_stderr.read
-
   $SiB.record_exception nil, $! if $!
-  $SiB.finish!
+  finish.call
+  Kernel.exit! 0 # clear the exception so it doesn't print to stderr and change the processes actual exit status (we recorded what it should be)
 end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '3.0.0.beta.3'
+  VERSION = '3.0.0.beta.4'
 end

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -1,4 +1,3 @@
-require 'parser/current'
 require 'seeing_is_believing/parser_helpers'
 
 # comprehensive list of syntaxes that can come up

data/lib/seeing_is_believing.rb

@@ -23,7 +23,6 @@ class SeeingIsBelieving
     @encoding           = options.fetch :encoding,  nil
     @timeout            = options[:timeout]
     @debugger           = options.fetch :debugger, Debugger.new(stream: nil)
-    @ruby_executable    = options.fetch :ruby_executable, 'ruby'
     @number_of_captures = options.fetch :number_of_captures, Float::INFINITY
     @evaluator          = options.fetch :evaluator, EvaluateByMovingFiles
     @record_expressions = options.fetch :record_expressions, InspectExpressions # TODO: rename to wrap_expressions
@@ -42,7 +41,6 @@ class SeeingIsBelieving
                       load_path:          @load_path,
                       encoding:           @encoding,
                       timeout:            @timeout,
-                      ruby_executable:    @ruby_executable,
                       debugger:           @debugger
 
       @debugger.context("RESULT") { result.inspect }

data/seeing_is_believing.gemspec

@@ -19,11 +19,9 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency             "eval_in",  "~> 0.1.6"
-  s.add_dependency             "parser",   ">= 2.1.4",  "< 2.3"
+  s.add_dependency             "parser",   ">= 2.2", "< 3.0"
 
-  s.add_development_dependency "webmock",  "~>  1.18"
-  s.add_development_dependency "haiti",    ">= 0.1",    "< 0.3"
+  s.add_development_dependency "haiti",    ">= 0.1", "< 0.3"
   s.add_development_dependency "rake",     "~> 10.0"
   s.add_development_dependency "rspec",    "~>  3.0"
   s.add_development_dependency "cucumber", "~>  1.2"

data/spec/binary/interpret_flags_spec.rb

@@ -131,12 +131,6 @@ class SeeingIsBelieving
         end
       end
 
-      context 'shebang' do
-        it 'sets shebang to the value' do
-          expect(call(shebang: 'whatevz').shebang).to eq 'whatevz'
-        end
-      end
-
       context 'filename' do
         it 'sets this as the filename' do
           expect(call(filename: 'somefilename').filename).to eq 'somefilename'
@@ -239,20 +233,12 @@ class SeeingIsBelieving
           expect(call[:evaluate_with]).to eq EvaluateByMovingFiles
         end
 
-        specify 'evaluate_with is EvaluateWithEvalIn if safe is set' do
-          expect(call(safe: true)[:evaluate_with]).to eq EvaluateWithEvalIn
-        end
-
         specify 'filename is the as option or the provided filename' do
           expect(call(filename: 'from_fn')[:filename]).to eq 'from_fn'
           expect(call(as: 'from_as')[:filename]).to eq 'from_as'
           expect(call(as: 'from_as', filename: 'from_fn')[:filename]).to eq 'from_as'
         end
 
-        specify 'ruby_executable is the shebang' do
-          expect(call(shebang: 'shebangprog')[:ruby_executable]).to eq 'shebangprog'
-        end
-
         specify 'stdin is empty when the program is on stdin, and is stdin otherwise' do
           # NOTE: the lib will normalize this into a stream
           expect(call(filename: nil, program_from_args: nil)[:stdin]).to eq ''

data/spec/binary/parse_args_spec.rb

@@ -341,12 +341,11 @@ RSpec.describe SeeingIsBelieving::Binary::ParseArgs do
   end
 
   describe ':shebang' do
-    it 'defaults to "ruby"' do
-      expect(parse([])[:shebang]).to eq 'ruby'
-    end
-
-    it 'can be enabled with --shebang' do
-      expect(parse(['--shebang', 'not_ruby'])[:shebang]).to eq 'not_ruby'
+    it 'is added to the list of deprecated flags' do
+      expect(parse([])[:deprecated_flags]).to eq []
+      parsed = parse(['--shebang', 'not_ruby', 'other'])
+      expect(parsed[:shebang]).to eq nil
+      expect(parsed[:deprecated_flags]).to eq ['--shebang', 'not_ruby']
     end
 
     it 'sets an error if not given a next arg to execute' do

data/spec/event_stream_spec.rb

@@ -5,28 +5,54 @@ require 'seeing_is_believing/event_stream/consumer'
 
 module SeeingIsBelieving::EventStream
   RSpec.describe SeeingIsBelieving::EventStream do
-    attr_accessor :producer, :consumer, :readstream, :writestream
+    attr_accessor :producer, :consumer
+    attr_accessor :eventstream_consumer, :eventstream_producer
+    attr_accessor :stdout_consumer, :stdout_producer
+    attr_accessor :stderr_consumer, :stderr_producer
 
-    before do
-      self.readstream, self.writestream = IO.pipe
-      self.producer  = SeeingIsBelieving::EventStream::Producer.new(writestream)
-      self.consumer  = SeeingIsBelieving::EventStream::Consumer.new(readstream)
+    def close_streams(*streams)
+      streams.each { |fd| fd.close unless fd.closed? }
     end
 
-    after {
+    def finish!
       producer.finish!
-      readstream.close  unless readstream.closed?
-      writestream.close unless writestream.closed?
-    }
+      close_streams eventstream_producer, stdout_producer, stderr_producer
+    end
+
+    before do
+      self.eventstream_consumer, self.eventstream_producer = IO.pipe
+      self.stdout_consumer,      self.stdout_producer      = IO.pipe
+      self.stderr_consumer,      self.stderr_producer      = IO.pipe
+
+      self.producer = SeeingIsBelieving::EventStream::Producer.new eventstream_producer
+      self.consumer = SeeingIsBelieving::EventStream::Consumer.new \
+        events: eventstream_consumer,
+        stdout: stdout_consumer,
+        stderr: stderr_consumer
+    end
+
+    after do
+      finish!
+      close_streams eventstream_consumer, stdout_consumer, stderr_consumer
+    end
 
     describe 'emitting an event' do
-      # TODO: could not fucking figure out how to ask the goddam thing if it has data
-      # read docs for over an hour -.0
-      it 'writes a line to stdout'
+      def has_message?(io)
+        io.read_nonblock(1)  # ~> IO::EAGAINWaitReadable: Resource temporarily unavailable - read would block
+      rescue Errno::EAGAIN
+        return false
+      end
+
+      it 'writes its events to the event stream' do
+        read, write = IO.pipe
+        producer = SeeingIsBelieving::EventStream::Producer.new(write)
+        expect(has_message? read).to eq false
+        producer.record_filename "whatever.rb"
+        expect(read.gets).to start_with 'filename'
+      end
 
-      # This test is irrelevant on MRI b/c of the GIL,
-      # but I ran it on Rbx to make sure it works
-      it 'is wrapped in a mutex to prevent multiple values from writing at the same time' do
+      # This test is irrelevant on MRI b/c of the GIL, but I ran it on Rbx to make sure it works
+      it 'is threadsafe as multiple events can occur at once' do
         num_threads = 10
         num_results = 600
         line_nums_and_inspections = num_threads.times.flat_map { |line_num|
@@ -51,58 +77,58 @@ module SeeingIsBelieving::EventStream
         expect(producer_threads).to be_none(&:alive?)
       end
 
-      it 'raises NoMoreInput and marks itself finished if input is closed before it finishes reading the number of requested inputs' do
-        producer.finish!
+      it 'raises NoMoreInput 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
       end
 
-      it 'raises NoMoreInput and marks itself finished once it receives the finish event' do
+      it 'raises NoMoreInput once it its input streams are all closed' do
         producer.finish!
-        consumer.call 4
+        close_streams eventstream_producer, stdout_producer, stderr_producer
+        consumer.call 2
         expect { consumer.call }.to raise_error SeeingIsBelieving::EventStream::Consumer::NoMoreInput
-        expect(consumer).to be_finished
       end
 
-      it 'raises NoMoreInput and marks itself finished once the other end of the stream is closed' do
-        writestream.close
+      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
-        expect(consumer).to be_finished
       end
 
-      it 'raises WtfWhoClosedMyShit and marks itself finished if its end of the stream is closed' do
-        readstream.close
+      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
-        expect(consumer).to be_finished
       end
     end
 
     describe 'each' do
-      it 'loops through and yields all events except the finish event' do
+      it 'loops through and yields all events' do
         producer.record_result :inspect, 100, 2
-        producer.finish!
+        finish!
 
         events = []
         consumer.each { |e| events << e }
-        finish_event = events.find { |e| e.kind_of? Events::Finish }
         line_result  = events.find { |e| e.kind_of? Events::LineResult }
         exitstatus   = events.find { |e| e.kind_of? Events::Exitstatus }
-        expect(finish_event).to be_nil
         expect(line_result.line_number).to eq 100
         expect(exitstatus.value).to eq 0
       end
 
       it 'stops looping if there is no more input' do
-        writestream.close
-        expect(consumer.each.map { |e| e }).to eq []
+        finish!
+        expect(consumer.each.map { |e| e }).to eq [
+          Events::NumLines.new(0),
+          Events::Exitstatus.new(0),
+        ]
       end
 
       it 'returns nil' do
-        producer.finish!
+        finish!
         expect(consumer.each { 1 }).to eq nil
       end
 
       it 'returns an enumerator if not given a block' do
-        producer.finish!
+        finish!
         expect(consumer.each.map &:class).to include Events::Exitstatus
       end
     end
@@ -257,6 +283,29 @@ module SeeingIsBelieving::EventStream
       end
     end
 
+    describe 'max_line_captures (value and recording)' do
+      it 'is infinity by default' do
+        expect(producer.max_line_captures).to eq Float::INFINITY
+      end
+
+      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)
+      end
+
+      it 'interprets numbers' do
+        producer.record_max_line_captures 12
+        expect(consumer.call).to eq Events::MaxLineCaptures.new(12)
+      end
+
+      it 'interprets infinity' do
+        producer.record_max_line_captures Float::INFINITY
+        expect(consumer.call).to eq Events::MaxLineCaptures.new(Float::INFINITY)
+      end
+    end
+
+
     describe 'exceptions' do
       def record_exception(linenum=nil, &raises_exception)
         raises_exception.call
@@ -326,45 +375,45 @@ module SeeingIsBelieving::EventStream
       context 'recorded line number | line num is provided | it knows the file | exception comes from within file' do
         let(:exception) { begin; raise "zomg"; rescue; $!; end }
         let(:linenum)   { __LINE__ - 1 }
-        it "provided one       | true                 | true              | true" do
+        example "provided one       | true                 | true              | true" do
           producer.filename = __FILE__
           producer.record_exception 12, exception
           assert_exception consumer.call, recorded_line_no: 12
         end
-        it "provided one       | true                 | true              | false" do
+        example "provided one       | true                 | true              | false" do
           exception.backtrace.replace ['otherfile.rb']
           producer.record_exception 12, exception
           producer.filename = __FILE__
           assert_exception consumer.call, recorded_line_no: 12
         end
-        it "provided one       | true                 | false             | true" do
+        example "provided one       | true                 | false             | true" do
           producer.filename = nil
           producer.record_exception 12, exception
           assert_exception consumer.call, recorded_line_no: 12
         end
-        it "provided one       | true                 | false             | false" do
+        example "provided one       | true                 | false             | false" do
           exception.backtrace.replace ['otherfile.rb']
           producer.filename = nil
           producer.record_exception 12, exception
           assert_exception consumer.call, recorded_line_no: 12
         end
-        it "from backtrace     | false                | true              | true" do
+        example "from backtrace     | false                | true              | true" do
           producer.filename = __FILE__
           producer.record_exception nil, exception
           assert_exception consumer.call, recorded_line_no: linenum
         end
-        it "-1                 | false                | true              | false" do
+        example "-1                 | false                | true              | false" do
           exception.backtrace.replace ['otherfile.rb']
           producer.filename = __FILE__
           producer.record_exception nil, exception
           assert_exception consumer.call, recorded_line_no: -1
         end
-        it "-1                 | false                | false             | true" do
+        example "-1                 | false                | false             | true" do
           producer.filename = nil
           producer.record_exception nil, exception
           assert_exception consumer.call, recorded_line_no: -1
         end
-        it "-1                 | false                | false             | false" do
+        example "-1                 | false                | false             | false" do
           exception.backtrace.replace ['otherfile.rb']
           producer.filename = nil
           producer.record_exception nil, exception
@@ -373,40 +422,83 @@ module SeeingIsBelieving::EventStream
       end
     end
 
+    describe 'seeing is believing version' do
+      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")
+        end
+      end
+
+      specify 'version return the version, if it has been set' do
+        expect(producer.version).to eq nil
+        producer.record_sib_version '4.5.6'
+        expect(producer.version).to eq '4.5.6'
+      end
+    end
+
+    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.')
+      end
+    end
+
+    describe 'record_filename' do
+      it 'sets the filename' do
+        producer.record_filename 'this-iz-mah-file.rb'
+        expect(producer.filename).to eq 'this-iz-mah-file.rb'
+      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')
+      end
+    end
+
     describe 'stdout' do
-      it 'is an escaped string' do
-        producer.record_stdout("this is the stdout¡")
-        expect(consumer.call).to eq Events::Stdout.new("this is the stdout¡")
+      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")
+      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")
       end
     end
 
     describe 'stderr' do
-      it 'is an escaped string' do
-        producer.record_stderr("this is the stderr¡")
-        expect(consumer.call).to eq Events::Stderr.new("this is the stderr¡")
+      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")
+      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")
       end
     end
 
+
     describe 'finish!' do
       def final_event(producer, consumer, event_class)
-        producer.finish!
-        consumer.call(4).find { |e| e.class == event_class }
+        finish!
+        consumer.call(2).find { |e| e.class == event_class }
       end
 
-      describe 'max_line_captures' do
-        it 'interprets numbers' do
-          producer.max_line_captures = 12
-          expect(final_event(producer, consumer, Events::MaxLineCaptures).value).to eq 12
-        end
-
-        it 'interprets infinity' do
-          producer.max_line_captures = Float::INFINITY
-          expect(final_event(producer, consumer, Events::MaxLineCaptures).value).to eq Float::INFINITY
-        end
-
-        it 'is infinity by default' do
-          expect(final_event(producer, consumer, Events::MaxLineCaptures).value).to eq Float::INFINITY
-        end
+      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
 
       describe 'num_lines' do
@@ -443,13 +535,12 @@ module SeeingIsBelieving::EventStream
           expect(final_event(producer, consumer, Events::Exitstatus).value).to eq 74
         end
       end
+    end
 
-      describe 'finish' do
-        it 'is the last thing that will be read' do
-          expect(final_event(producer, consumer, Events::Finish)).to be_a_kind_of Events::Finish
-          expect { p consumer.call }.to raise_error SeeingIsBelieving::EventStream::Consumer::NoMoreInput
-        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/
     end
   end
 end