infopark-user_io 1.2.1 → 1.3.0

data/spec/user_io_spec.rb

@@ -1,337 +1,300 @@
-module Infopark
+# frozen_string_literal: true
 
-RSpec.describe UserIO do
-  let(:options) { {} }
+module Infopark
+  RSpec.describe(UserIO) do
+    let(:options) { {} }
 
-  subject(:user_io) { UserIO.new(**options) }
+    subject(:user_io) { UserIO.new(**options) }
 
-  before do
-    allow($stdout).to receive(:puts)
-    # for debugging: .and_call_original
-    allow($stdout).to receive(:write)
-    # for debugging: .and_call_original
-  end
+    before do
+      allow($stdout).to(receive(:puts))
+      # for debugging: .and_call_original
+      allow($stdout).to(receive(:write))
+      # for debugging: .and_call_original
+    end
 
-  describe ".global" do
-    subject(:global) { UserIO.global }
+    describe ".global" do
+      subject(:global) { UserIO.global }
 
-    it { is_expected.to be_nil }
-  end
+      it { is_expected.to(be_nil) }
+    end
 
-  describe ".global=" do
-    subject(:assign_global) { UserIO.global = user_io }
+    describe ".global=" do
+      subject(:assign_global) { UserIO.global = user_io }
 
-    it "assigns the global UserIO" do
-      expect {
-        assign_global
-      }.to change {
-        UserIO.global
-      }.to(user_io)
+      it "assigns the global UserIO" do
+        expect { assign_global }.to(change { UserIO.global }.to(user_io))
+      end
     end
-  end
 
-  describe "#acknowledge" do
-    before { allow($stdin).to receive(:gets).and_return("\n") }
+    describe "#acknowledge" do
+      before { allow($stdin).to(receive(:gets).and_return("\n")) }
 
-    let(:message) { "Some important statement." }
+      let(:message) { "Some important statement." }
 
-    subject(:acknowledge) { user_io.acknowledge(message) }
+      subject(:acknowledge) { user_io.acknowledge(message) }
 
-    it "presents the message (colorized)" do
-      expect($stdout).to receive(:write).with("\e[1;36m""Some important statement.""\e[22;39m\n")
-      acknowledge
-    end
+      it "presents the message (colorized)" do
+        expect($stdout).to(receive(:write).with("\e[1;36mSome important statement.\e[22;39m\n"))
+        acknowledge
+      end
 
-    it "asks for pressing “Enter”" do
-      expect($stdout).to receive(:write).with("Please press ENTER to continue.\n")
-      acknowledge
-    end
+      it "asks for pressing “Enter”" do
+        expect($stdout).to(receive(:write).with("Please press ENTER to continue.\n"))
+        acknowledge
+      end
 
-    it "requests input" do
-      expect($stdin).to receive(:gets).and_return("\n")
-      acknowledge
+      it "requests input" do
+        expect($stdin).to(receive(:gets).and_return("\n"))
+        acknowledge
+      end
     end
-  end
 
-  describe "#ask" do
-    before { allow($stdin).to receive(:gets).and_return("yes\n") }
+    describe "#ask" do
+      before { allow($stdin).to(receive(:gets).and_return("yes\n")) }
 
-    let(:ask_options) { {} }
-    let(:question) { "do you want to?" }
+      let(:ask_options) { {} }
+      let(:question) { "do you want to?" }
 
-    subject(:ask) { user_io.ask(*Array(question), **ask_options) }
+      subject(:ask) { user_io.ask(*Array(question), **ask_options) }
 
-    shared_examples_for "any question" do
-      # TODO
-      #it_behaves_like "handling valid answer"
-      #it_behaves_like "handling invalid input"
-      #it_behaves_like "printing prefix on every line"
-    end
+      shared_examples_for "any question" do
+        # TODO
+        # it_behaves_like "handling valid answer"
+        # it_behaves_like "handling invalid input"
+        # it_behaves_like "printing prefix on every line"
+      end
 
-    context "with default" do
-      let(:ask_options) { {default: default_value} }
+      context "with default" do
+        let(:ask_options) { {default: default_value} }
 
-      context "“true”" do
-        let(:default_value) { true }
+        context "“true”" do
+          let(:default_value) { true }
 
-        it "presents default answer “yes”" do
-          expect($stdout).to receive(:write).with("(yes/no) [yes] > ")
-          ask
-        end
+          it "presents default answer “yes”" do
+            expect($stdout).to(receive(:write).with("(yes/no) [yes] > "))
+            ask
+          end
 
-        it "returns “true” on empty input" do
-          expect($stdin).to receive(:gets).and_return("\n")
-          expect(ask).to be true
+          it "returns “true” on empty input" do
+            expect($stdin).to(receive(:gets).and_return("\n"))
+            expect(ask).to(be(true))
+          end
+
+          it_behaves_like "any question"
         end
 
-        it_behaves_like "any question"
-      end
+        context "“false”" do
+          let(:default_value) { false }
+
+          it "presents default answer “no”" do
+            expect($stdout).to(receive(:write).with("(yes/no) [no] > "))
+            ask
+          end
 
-      context "“false”" do
-        let(:default_value) { false }
+          it "returns “false” on empty input" do
+            expect($stdin).to(receive(:gets).and_return("\n"))
+            expect(ask).to(be(false))
+          end
 
-        it "presents default answer “no”" do
-          expect($stdout).to receive(:write).with("(yes/no) [no] > ")
-          ask
+          it_behaves_like "any question"
         end
 
-        it "returns “false” on empty input" do
-          expect($stdin).to receive(:gets).and_return("\n")
-          expect(ask).to be false
+        context "non boolean" do
+          # TODO
         end
-
-        it_behaves_like "any question"
       end
 
-      context "non boolean" do
-        # TODO
-      end
-    end
+      context "with “expected”" do
+        let(:ask_options) { {expected: expected_value} }
 
-    context "with “expected”" do
-      let(:ask_options) { {expected: expected_value} }
+        context "“yes”" do
+          let(:expected_value) { "yes" }
 
-      context "“yes”" do
-        let(:expected_value) { "yes" }
+          it_behaves_like "any question"
 
-        it_behaves_like "any question"
+          it "returns “true” when answering “yes”" do
+            expect($stdin).to(receive(:gets).and_return("yes\n"))
+            expect(ask).to(be(true))
+          end
 
-        it "returns “true” when answering “yes”" do
-          expect($stdin).to receive(:gets).and_return("yes\n")
-          expect(ask).to be true
+          it "returns “false” when answering “no”" do
+            expect($stdin).to(receive(:gets).and_return("no\n"))
+            expect(ask).to(be(false))
+          end
         end
 
-        it "returns “false” when answering “no”"do
-          expect($stdin).to receive(:gets).and_return("no\n")
-          expect(ask).to be false
-        end
-      end
+        context "“no”" do
+          let(:expected_value) { "no" }
 
-      context "“no”" do
-        let(:expected_value) { "no" }
+          it_behaves_like "any question"
 
-        it_behaves_like "any question"
+          it "returns “true” when answering “no”" do
+            expect($stdin).to(receive(:gets).and_return("no\n"))
+            expect(ask).to(be(true))
+          end
 
-        it "returns “true” when answering “no”" do
-          expect($stdin).to receive(:gets).and_return("no\n")
-          expect(ask).to be true
+          it "returns “false” when answering “yes”" do
+            expect($stdin).to(receive(:gets).and_return("yes\n"))
+            expect(ask).to(be(false))
+          end
         end
 
-        it "returns “false” when answering “yes”" do
-          expect($stdin).to receive(:gets).and_return("yes\n")
-          expect(ask).to be false
+        context "other" do
+          # TODO
         end
       end
-
-      context "other" do
-        # TODO
-      end
     end
-  end
 
-  describe "#select" do
-    before { allow($stdin).to receive(:gets).and_return("1\n") }
+    describe "#select" do
+      before { allow($stdin).to(receive(:gets).and_return("1\n")) }
 
-    let(:description) { "a thing" }
-    let(:items) { [:a, :b, :c] }
-    let(:select_options) { {} }
+      let(:description) { "a thing" }
+      let(:items) { %i[a b c] }
+      let(:select_options) { {} }
 
-    subject(:select) { user_io.select(description, items, **select_options) }
+      subject(:select) { user_io.select(description, items, **select_options) }
 
-    context "with default" do
-      let(:select_options) { {default: :b} }
+      context "with default" do
+        let(:select_options) { {default: :b} }
 
-      it "presents the default's index as default answer" do
-        expect($stdout).to receive(:write).with("Your choice [2] > ")
-        select
-      end
+        it "presents the default's index as default answer" do
+          expect($stdout).to(receive(:write).with("Your choice [2] > "))
+          select
+        end
 
-      it "returns the default on empty input" do
-        expect($stdin).to receive(:gets).and_return("\n")
-        expect(select).to eq(:b)
+        it "returns the default on empty input" do
+          expect($stdin).to(receive(:gets).and_return("\n"))
+          expect(select).to(eq(:b))
+        end
       end
     end
-  end
 
-  describe "#tell_error" do
-    let(:error) { {my: :error} }
-    let(:tell_options) { {} }
-
-    subject(:tell_error) { user_io.tell_error(error, **tell_options) }
-
-    it "tells the given thing in bright red" do
-      expect(user_io).to receive(:tell).with(error, color: :red, bright: true)
-      tell_error
-    end
+    describe "#tell_error" do
+      let(:error) { {my: :error} }
+      let(:tell_options) { {} }
 
-    context "with options" do
-      let(:tell_options) { {newline: false} }
+      subject(:tell_error) { user_io.tell_error(error, **tell_options) }
 
-      it "delegates them to #tell" do
-        expect(user_io).to receive(:tell).with(error, newline: false, color: :red, bright: true)
+      it "tells the given thing in bright red" do
+        expect(user_io).to(receive(:tell).with(error, color: :red, bright: true))
         tell_error
       end
-    end
-
-    context "when error is a kind of an exception" do
-      let(:error) { UserIO::Aborted.new }
 
-      before { allow(error).to receive(:backtrace).and_return(%w(a b c)) }
+      context "with options" do
+        let(:tell_options) { {newline: false} }
 
-      it "tells the error and the whole backtrace" do
-        expect(user_io).to receive(:tell).with(error, color: :red, bright: true)
-        expect(user_io).to receive(:tell).with(%w(a b c), color: :red)
-        tell_error
+        it "delegates them to #tell" do
+          expect(user_io).to(receive(:tell).with(error, newline: false, color: :red, bright: true))
+          tell_error
+        end
       end
-    end
-  end
 
-  describe "#tell_pty_stream" do
-    let(:color_options) { {} }
-    let(:stream) { instance_double(IO) }
-    let(:data) { "test data" }
+      context "when error is a kind of an exception" do
+        let(:error) { UserIO::Aborted.new }
 
-    subject(:tell) { user_io.tell_pty_stream(stream, **color_options) }
+        before { allow(error).to(receive(:backtrace).and_return(%w(a b c))) }
 
-    before do
-      chunks = Array(data)
-      allow(stream).to receive(:eof?).and_return(*[false] * chunks.size, true)
-      allow(stream).to receive(:read_nonblock).and_return(*chunks)
-      RSpec::Mocks.space.proxy_for($stdout).reset
-      allow($stdout).to receive(:write).with(nil)
+        it "tells the error and the whole backtrace" do
+          expect(user_io).to(receive(:tell).with(error, color: :red, bright: true))
+          expect(user_io).to(receive(:tell).with(%w(a b c), color: :red))
+          tell_error
+        end
+      end
     end
 
-    it "tells all data from stream in non blocking chunks" do
-      expect(stream).to receive(:eof?).and_return(false, false, false, true)
-      expect(stream).to receive(:read_nonblock).with(100).
-          and_return("first\nchunk", "second chunk", "\nlast chunk")
-      expect($stdout).to receive(:write).with("first\nchunk")
-      expect($stdout).to receive(:write).with("second chunk")
-      expect($stdout).to receive(:write).with("\nlast chunk")
-      tell
-    end
+    describe "#tell_pty_stream" do
+      let(:color_options) { {} }
+      let(:stream) { instance_double(IO) }
+      let(:data) { "test data" }
 
-    context "with color" do
-      let(:color_options) { {color: :yellow} }
+      subject(:tell) { user_io.tell_pty_stream(stream, **color_options) }
 
-      it "colorizes the output" do
-        expect($stdout).to receive(:write).with("\e[33m").ordered
-        expect($stdout).to receive(:write).with("test data").ordered
-        expect($stdout).to receive(:write).with("\e[22;39m").ordered
-        tell
+      before do
+        chunks = Array(data)
+        allow(stream).to(receive(:eof?).and_return(*[false] * chunks.size, true))
+        allow(stream).to(receive(:read_nonblock).and_return(*chunks))
+        RSpec::Mocks.space.proxy_for($stdout).reset
+        allow($stdout).to(receive(:write).with(nil))
       end
-    end
 
-    context "with output_prefix" do
-      let(:options) { {output_prefix: "the prefix"} }
-
-      it "prefixes the output" do
-        expect($stdout).to receive(:write).with("[the prefix] ").ordered
-        expect($stdout).to receive(:write).with("test data").ordered
+      it "tells all data from stream in non blocking chunks" do
+        expect(stream).to(receive(:eof?).and_return(false, false, false, true))
+        expect(stream).to(receive(:read_nonblock).with(100)
+            .and_return("first\nchunk", "second chunk", "\nlast chunk"))
+        expect($stdout).to(receive(:write).with("first\nchunk"))
+        expect($stdout).to(receive(:write).with("second chunk"))
+        expect($stdout).to(receive(:write).with("\nlast chunk"))
         tell
       end
 
       context "with color" do
         let(:color_options) { {color: :yellow} }
 
-        it "does not colorize the prefix" do
-          expect($stdout).to receive(:write).with("[the prefix] ").ordered
-          expect($stdout).to receive(:write).with("\e[33m").ordered
-          expect($stdout).to receive(:write).with("test data").ordered
-          expect($stdout).to receive(:write).with("\e[22;39m").ordered
+        it "colorizes the output" do
+          expect($stdout).to(receive(:write).with("\e[33m").ordered)
+          expect($stdout).to(receive(:write).with("test data").ordered)
+          expect($stdout).to(receive(:write).with("\e[22;39m").ordered)
           tell
         end
       end
 
-      context "when stream contains carriage return" do
-        let(:data) { "some\rdata\rwith\rCRs" }
+      context "with output_prefix" do
+        let(:options) { {output_prefix: "the prefix"} }
 
-        it "writes the prefix right after the CR" do
-          expect($stdout).to receive(:write).with("[the prefix] ").ordered
-          expect($stdout).to receive(:write).
-              with("some\r[the prefix] data\r[the prefix] with\r[the prefix] CRs").ordered
+        it "prefixes the output" do
+          expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
+          expect($stdout).to(receive(:write).with("test data").ordered)
           tell
         end
 
         context "with color" do
           let(:color_options) { {color: :yellow} }
 
-          it "uncolorizes the prefix" do
-            expect($stdout).to receive(:write).with("[the prefix] ").ordered
-            expect($stdout).to receive(:write).with("\e[33m").ordered
-            expect($stdout).to receive(:write).with(
-              "some\r"\
-              "\e[22;39m" "[the prefix] " "\e[33m" "data\r"\
-              "\e[22;39m" "[the prefix] " "\e[33m" "with\r"\
-              "\e[22;39m" "[the prefix] " "\e[33m" "CRs"
-            ).ordered
-            expect($stdout).to receive(:write).with("\e[22;39m").ordered
+          it "does not colorize the prefix" do
+            expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
+            expect($stdout).to(receive(:write).with("\e[33m").ordered)
+            expect($stdout).to(receive(:write).with("test data").ordered)
+            expect($stdout).to(receive(:write).with("\e[22;39m").ordered)
             tell
           end
         end
-      end
 
-      context "when stream contains newline" do
-        let(:data) { "some\ndata\nwith\nNLs" }
+        context "when stream contains carriage return" do
+          let(:data) { "some\rdata\rwith\rCRs" }
 
-        it "writes the prefix right after the NL" do
-          expect($stdout).to receive(:write).with("[the prefix] ").ordered
-          expect($stdout).to receive(:write).
-              with("some\n[the prefix] data\n[the prefix] with\n[the prefix] NLs")
-          tell
-        end
+          it "writes the prefix right after the CR" do
+            expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
+            expect($stdout).to(receive(:write)
+                .with("some\r[the prefix] data\r[the prefix] with\r[the prefix] CRs").ordered)
+            tell
+          end
 
-        context "with color" do
-          let(:color_options) { {color: :yellow} }
+          context "with color" do
+            let(:color_options) { {color: :yellow} }
 
-          it "uncolorizes the prefix" do
-            expect($stdout).to receive(:write).with("[the prefix] ").ordered
-            expect($stdout).to receive(:write).with("\e[33m").ordered
-            expect($stdout).to receive(:write).with(
-              "some\n"\
-              "\e[22;39m" "[the prefix] " "\e[33m" "data\n"\
-              "\e[22;39m" "[the prefix] " "\e[33m" "with\n"\
-              "\e[22;39m" "[the prefix] " "\e[33m" "NLs"
-            ).ordered
-            expect($stdout).to receive(:write).with("\e[22;39m").ordered
-            tell
+            it "uncolorizes the prefix" do
+              expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
+              expect($stdout).to(receive(:write).with("\e[33m").ordered)
+              expect($stdout).to(receive(:write).with(
+                "some\r" \
+                "\e[22;39m[the prefix] \e[33mdata\r" \
+                "\e[22;39m[the prefix] \e[33mwith\r" \
+                "\e[22;39m[the prefix] \e[33mCRs",
+              ).ordered)
+              expect($stdout).to(receive(:write).with("\e[22;39m").ordered)
+              tell
+            end
           end
         end
 
-        context "when stream ends with newline" do
-          # includes an empty chunk to verify, that they don't consume the pending NL
-          let(:data) { ["some\n", "data\n", "with\n", "", "NLs\n", ""] }
-
-          it "does not write prefix after the last newline" do
-            expect($stdout).to receive(:write).with("[the prefix] ").ordered
-            expect($stdout).to receive(:write).with("some").ordered
-            expect($stdout).to receive(:write).with("\n" "[the prefix] ").ordered
-            expect($stdout).to receive(:write).with("data").ordered
-            expect($stdout).to receive(:write).with("\n" "[the prefix] ").ordered
-            expect($stdout).to receive(:write).with("with").ordered
-            expect($stdout).to receive(:write).with("\n" "[the prefix] ").ordered
-            expect($stdout).to receive(:write).with("NLs").ordered
-            expect($stdout).to receive(:write).with("\n").ordered
+        context "when stream contains newline" do
+          let(:data) { "some\ndata\nwith\nNLs" }
+
+          it "writes the prefix right after the NL" do
+            expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
+            expect($stdout).to(receive(:write)
+                .with("some\n[the prefix] data\n[the prefix] with\n[the prefix] NLs"))
             tell
           end
 
@@ -339,92 +302,121 @@ RSpec.describe UserIO do
             let(:color_options) { {color: :yellow} }
 
             it "uncolorizes the prefix" do
-              expect($stdout).to receive(:write).with("[the prefix] ").ordered
-              expect($stdout).to receive(:write).with("\e[33m").ordered
-              expect($stdout).to receive(:write).with("some").ordered
-              expect($stdout).to receive(:write).
-                  with("\n" "\e[22;39m" "[the prefix] " "\e[33m").ordered
-              expect($stdout).to receive(:write).with("data").ordered
-              expect($stdout).to receive(:write).
-                  with("\n" "\e[22;39m" "[the prefix] " "\e[33m").ordered
-              expect($stdout).to receive(:write).with("with").ordered
-              expect($stdout).to receive(:write).
-                  with("\n" "\e[22;39m" "[the prefix] " "\e[33m").ordered
-              expect($stdout).to receive(:write).with("NLs").ordered
-              expect($stdout).to receive(:write).with("\n").ordered
-              expect($stdout).to receive(:write).with("\e[22;39m").ordered
+              expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
+              expect($stdout).to(receive(:write).with("\e[33m").ordered)
+              expect($stdout).to(receive(:write).with(
+                "some\n" \
+                "\e[22;39m[the prefix] \e[33mdata\n" \
+                "\e[22;39m[the prefix] \e[33mwith\n" \
+                "\e[22;39m[the prefix] \e[33mNLs",
+              ).ordered)
+              expect($stdout).to(receive(:write).with("\e[22;39m").ordered)
               tell
             end
           end
-        end
-      end
 
-      context "when data does not end with newline" do
-        let(:data) { "foo" }
+          context "when stream ends with newline" do
+            # includes an empty chunk to verify, that they don't consume the pending NL
+            let(:data) { ["some\n", "data\n", "with\n", "", "NLs\n", ""] }
+
+            it "does not write prefix after the last newline" do
+              expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
+              expect($stdout).to(receive(:write).with("some").ordered)
+              expect($stdout).to(receive(:write).with("\n[the prefix] ").ordered)
+              expect($stdout).to(receive(:write).with("data").ordered)
+              expect($stdout).to(receive(:write).with("\n[the prefix] ").ordered)
+              expect($stdout).to(receive(:write).with("with").ordered)
+              expect($stdout).to(receive(:write).with("\n[the prefix] ").ordered)
+              expect($stdout).to(receive(:write).with("NLs").ordered)
+              expect($stdout).to(receive(:write).with("\n").ordered)
+              tell
+            end
 
-        it "writes prefix on next output nevertheless" do
-          expect($stdout).to receive(:write).with("[the prefix] ").ordered
-          expect($stdout).to receive(:write).with("foo").ordered
-          tell
-          expect($stdout).to receive(:write).with("[the prefix] next\n")
-          user_io.tell("next")
+            context "with color" do
+              let(:color_options) { {color: :yellow} }
+
+              it "uncolorizes the prefix" do
+                expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
+                expect($stdout).to(receive(:write).with("\e[33m").ordered)
+                expect($stdout).to(receive(:write).with("some").ordered)
+                expect($stdout).to(receive(:write).with("\n\e[22;39m[the prefix] \e[33m").ordered)
+                expect($stdout).to(receive(:write).with("data").ordered)
+                expect($stdout).to(receive(:write).with("\n\e[22;39m[the prefix] \e[33m").ordered)
+                expect($stdout).to(receive(:write).with("with").ordered)
+                expect($stdout).to(receive(:write).with("\n\e[22;39m[the prefix] \e[33m").ordered)
+                expect($stdout).to(receive(:write).with("NLs").ordered)
+                expect($stdout).to(receive(:write).with("\n").ordered)
+                expect($stdout).to(receive(:write).with("\e[22;39m").ordered)
+                tell
+              end
+            end
+          end
         end
-      end
 
-      context "when no newline was printed before" do
-        before do
-          expect($stdout).to receive(:write).with("[the prefix] no newline").ordered
-          user_io.tell("no newline", newline: false)
-        end
+        context "when data does not end with newline" do
+          let(:data) { "foo" }
 
-        it "does not prepend prefix" do
-          expect($stdout).to receive(:write).with("test data").ordered
-          tell
+          it "writes prefix on next output nevertheless" do
+            expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
+            expect($stdout).to(receive(:write).with("foo").ordered)
+            tell
+            expect($stdout).to(receive(:write).with("[the prefix] next\n"))
+            user_io.tell("next")
+          end
         end
 
-        it "prints prefix on following output" do
-          expect($stdout).to receive(:write).with("test data").ordered
-          tell
-          expect($stdout).to receive(:write).with("[the prefix] next\n")
-          user_io.tell("next")
+        context "when no newline was printed before" do
+          before do
+            expect($stdout).to(receive(:write).with("[the prefix] no newline").ordered)
+            user_io.tell("no newline", newline: false)
+          end
+
+          it "does not prepend prefix" do
+            expect($stdout).to(receive(:write).with("test data").ordered)
+            tell
+          end
+
+          it "prints prefix on following output" do
+            expect($stdout).to(receive(:write).with("test data").ordered)
+            tell
+            expect($stdout).to(receive(:write).with("[the prefix] next\n"))
+            user_io.tell("next")
+          end
         end
       end
-    end
 
-    context "when in background" do
-      let(:color_options) { {color: :yellow} }
-      let(:options) { {output_prefix: "foo"} }
-      let(:data) { ["data\n", "in\nchunks", "", "yo\n", ""] }
-
-      let!(:foreground_thread) do
-        @finished = false
-        Thread.new do
-          user_io.background_other_threads
-          sleep 0.1 until @finished
-          user_io.foreground
+      context "when in background" do
+        let(:color_options) { {color: :yellow} }
+        let(:options) { {output_prefix: "foo"} }
+        let(:data) { ["data\n", "in\nchunks", "", "yo\n", ""] }
+
+        let!(:foreground_thread) do
+          @finished = false
+          Thread.new do
+            user_io.background_other_threads
+            sleep(0.1) until @finished
+            user_io.foreground
+          end
         end
-      end
 
-      after { foreground_thread.kill.join }
+        after { foreground_thread.kill.join }
 
-      it "holds back the output until coming back to foreground" do
-        expect($stdout).to_not receive(:write)
-        tell
-        RSpec::Mocks.space.proxy_for($stdout).reset
-        expect($stdout).to receive(:write).with("[foo] ").ordered
-        expect($stdout).to receive(:write).with("\e[33m").ordered
-        expect($stdout).to receive(:write).with("data").ordered
-        expect($stdout).to receive(:write).with("\n" "\e[22;39m" "[foo] " "\e[33m").ordered
-        expect($stdout).to receive(:write).
-            with("in\n" "\e[22;39m" "[foo] " "\e[33m" "chunks").ordered
-        expect($stdout).to receive(:write).with("yo").ordered
-        expect($stdout).to receive(:write).with("\n").ordered
-        expect($stdout).to receive(:write).with("\e[22;39m").ordered
-        @finished = true
-        foreground_thread.join
+        it "holds back the output until coming back to foreground" do
+          expect($stdout).to_not(receive(:write))
+          tell
+          RSpec::Mocks.space.proxy_for($stdout).reset
+          expect($stdout).to(receive(:write).with("[foo] ").ordered)
+          expect($stdout).to(receive(:write).with("\e[33m").ordered)
+          expect($stdout).to(receive(:write).with("data").ordered)
+          expect($stdout).to(receive(:write).with("\n\e[22;39m[foo] \e[33m").ordered)
+          expect($stdout).to(receive(:write).with("in\n\e[22;39m[foo] \e[33mchunks").ordered)
+          expect($stdout).to(receive(:write).with("yo").ordered)
+          expect($stdout).to(receive(:write).with("\n").ordered)
+          expect($stdout).to(receive(:write).with("\e[22;39m").ordered)
+          @finished = true
+          foreground_thread.join
+        end
       end
     end
   end
 end
-
-end