tty-command 0.8.1 → 0.8.2

data/spec/unit/printers/quiet_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Command::Printers::Quiet do
+  let(:output) { StringIO.new }
+
+  it "doesn't print command start or exit" do
+    printer = TTY::Command::Printers::Quiet.new(output)
+    cmd = TTY::Command::Cmd.new("echo hello")
+
+    printer.print_command_start(cmd)
+    printer.print_command_exit(cmd, 0)
+    output.rewind
+
+    expect(output.string).to be_empty
+  end
+
+  it "prints command stdout data" do
+    printer = TTY::Command::Printers::Quiet.new(output)
+    cmd = TTY::Command::Cmd.new("echo hello")
+
+    printer.print_command_out_data(cmd, 'hello', 'world')
+    output.rewind
+
+    expect(output.string).to eq("hello world")
+  end
+
+  it "prints command stderr data" do
+    printer = TTY::Command::Printers::Quiet.new(output)
+    cmd = TTY::Command::Cmd.new("echo hello")
+
+    printer.print_command_err_data(cmd, 'hello', 'world')
+    output.rewind
+
+    expect(output.string).to eq("hello world")
+  end
+
+  it "doesn't print output on success when only_output_on_error is true" do
+    zero_exit = fixtures_path('zero_exit')
+    printer = TTY::Command::Printers::Quiet
+    cmd = TTY::Command.new(output: output, printer: printer)
+
+    cmd.run!(:ruby, zero_exit, only_output_on_error: true)
+    cmd.run!(:ruby, zero_exit)
+
+    output.rewind
+
+    lines = output.readlines.map(&:chomp)
+
+    expect(lines).to eq([
+      "yess"
+    ])
+  end
+
+  it "prints output on error when only_output_on_error is true" do
+    non_zero_exit = fixtures_path('non_zero_exit')
+    printer = TTY::Command::Printers::Quiet
+    cmd = TTY::Command.new(output: output, printer: printer)
+
+    cmd.run!(:ruby, non_zero_exit, only_output_on_error: true)
+    cmd.run!(:ruby, non_zero_exit)
+
+    output.rewind
+
+    lines = output.readlines.map(&:chomp)
+
+    expect(lines).to eq([
+      "nooo",
+      "nooo"
+    ])
+  end
+end

data/spec/unit/pty_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe TTY::Command, ':pty' do
+  it "executes command in pseudo terminal mode as global option",
+     unless: RSpec::Support::OS.windows? do
+
+    color_cli = fixtures_path('color')
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output, pty: true)
+
+    out, err = cmd.run(color_cli)
+
+    expect(err).to eq('')
+    expect(out).to eq("\e[32mcolored\e[0m\n")
+  end
+
+  it "executes command in pseudo terminal mode as command option",
+      unless: RSpec::Support::OS.windows? do
+
+    color_cli = fixtures_path('color')
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    out, err = cmd.run(color_cli, pty: true)
+
+    expect(err).to eq('')
+    expect(out).to eq("\e[32mcolored\e[0m\n")
+  end
+
+  it "logs phased output in pseudo terminal mode",
+      unless: RSpec::Support::OS.windows? do
+
+    phased_output = fixtures_path('phased_output')
+    uuid= 'xxxx'
+    allow(SecureRandom).to receive(:uuid).and_return(uuid)
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    out, err = cmd.run("ruby #{phased_output}", pty: true)
+
+    expect(out).to eq('.' * 10)
+    expect(err).to eq('')
+
+    output.rewind
+    lines = output.readlines
+    lines.last.gsub!(/\d+\.\d+/, 'x')
+    expect(lines).to eq([
+      "[\e[32m#{uuid}\e[0m] Running \e[33;1mruby #{phased_output}\e[0m\n",
+      "[\e[32m#{uuid}\e[0m] \t.\n",
+      "[\e[32m#{uuid}\e[0m] \t.\n",
+      "[\e[32m#{uuid}\e[0m] \t.\n",
+      "[\e[32m#{uuid}\e[0m] \t.\n",
+      "[\e[32m#{uuid}\e[0m] \t.\n",
+      "[\e[32m#{uuid}\e[0m] \t.\n",
+      "[\e[32m#{uuid}\e[0m] \t.\n",
+      "[\e[32m#{uuid}\e[0m] \t.\n",
+      "[\e[32m#{uuid}\e[0m] \t.\n",
+      "[\e[32m#{uuid}\e[0m] \t.\n",
+      "[\e[32m#{uuid}\e[0m] Finished in x seconds with exit status 0 (\e[32;1msuccessful\e[0m)\n"
+    ])
+  end
+end

data/spec/unit/redirect_spec.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+RSpec.describe TTY::Command, 'redirect' do
+  it "accepts standard shell redirects" do
+    output = StringIO.new
+    command = TTY::Command.new(output: output)
+
+    out, err = command.run("echo hello 1>& 2")
+
+    expect(out).to eq("")
+    expect(err).to match(%r{hello\s*\n})
+  end
+
+  it "redirects :out -> :err" do
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    out, err = cmd.run("echo hello", :out => :err)
+
+    expect(out).to be_empty
+    expect(err.chomp).to eq("hello")
+  end
+
+  it "redirects :stdout -> :stderr" do
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    out, err = cmd.run("echo hello", :stdout => :stderr)
+
+    expect(out).to be_empty
+    expect(err.chomp).to eq("hello")
+  end
+
+  it "redirects 1 -> 2" do
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    out, err = cmd.run("echo hello", 1 => 2)
+
+    expect(out).to be_empty
+    expect(err.chomp).to eq("hello")
+  end
+
+  it "redirects STDOUT -> :err" do
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    out, err = cmd.run("echo hello", STDOUT => :err)
+
+    expect(out).to be_empty
+    expect(err.chomp).to eq("hello")
+  end
+
+  it "redirects STDOUT -> '/dev/null" do
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    out, _ = cmd.run('echo hello', :out => IO::NULL)
+
+    expect(out).to eq("")
+  end
+
+  it "redirects to a file", type: :cli do
+    file = tmp_path('log')
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    out, err = cmd.run('echo hello', :out => file)
+
+    expect(out).to be_empty
+    expect(err).to be_empty
+    expect(File.read(file)).to eq("hello\n")
+  end
+
+  it "redirects to a file as an array value", type: :cli do
+    file = tmp_path('log')
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    expect(File.writable?(file)).to eq(false)
+    out, err = cmd.run('echo hello', :out => [file, 'w', 0600])
+
+    expect(out).to be_empty
+    expect(err).to be_empty
+    expect(File.read(file)).to eq("hello\n")
+    expect(File.writable?(file)).to eq(true)
+    unless RSpec::Support::OS.windows?
+      expect(File.stat(file).mode.to_s(8)[2..5]).to eq('0600')
+    end
+  end
+
+  it "redirects multiple fds to a file", type: :cli do
+    file = tmp_path('log')
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    out, err = cmd.run('echo hello', [:out, :err] => file)
+
+    expect(out).to be_empty
+    expect(err).to be_empty
+    expect(File.read(file)).to eq("hello\n")
+  end
+end

data/spec/unit/result_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Command::Result do
+  it "exits successfully" do
+    result = TTY::Command::Result.new(0, '', '')
+    expect(result.exited?).to eq(true)
+    expect(result.success?).to eq(true)
+  end
+
+  it "exist with non-zero code" do
+    result = TTY::Command::Result.new(127, '', '')
+    expect(result.exited?).to eq(true)
+    expect(result.success?).to eq(false)
+  end
+
+  it "accesses exit code" do
+    result = TTY::Command::Result.new(127, '', '')
+    expect(result.to_i).to eq(127)
+    expect(result.to_s).to eq('127')
+  end
+
+  it "provides runtime" do
+    result = TTY::Command::Result.new(0, '', '', 5.4)
+    expect(result.runtime).to eq(5.4)
+  end
+
+  it "doesn't exit" do
+    result = TTY::Command::Result.new(nil, '', '')
+    expect(result.exited?).to eq(false)
+    expect(result.success?).to eq(false)
+  end
+
+  it "reads stdout" do
+    result = TTY::Command::Result.new(0, 'foo', '')
+    expect(result.out).to eq('foo')
+  end
+
+  it "isn't equivalent with another object" do
+    result = TTY::Command::Result.new(0, '', '')
+    expect(result).to_not eq(:other)
+  end
+
+  it "is the same with equivalent object" do
+    result_foo = TTY::Command::Result.new(0, 'foo', 'bar')
+    result_bar = TTY::Command::Result.new(0, 'foo', 'bar')
+    expect(result_foo).to eq(result_bar)
+  end
+
+  it "iterates over output with default delimiter" do
+    result = TTY::Command::Result.new(0, "line1\nline2\nline3", '')
+    expect(result.to_a).to eq(['line1', 'line2', 'line3'])
+  end
+
+  it "iterates over output with global delimiter" do
+    allow(TTY::Command).to receive(:record_separator).and_return("\t")
+    result = TTY::Command::Result.new(0, "line1\tline2\tline3", '')
+    expect(result.each.to_a).to eq(['line1', 'line2', 'line3'])
+  end
+
+  it "iterates over output with argument delimiter" do
+    result = TTY::Command::Result.new(0, "line1\tline2\tline3", '')
+    expect(result.each("\t").to_a).to eq(['line1', 'line2', 'line3'])
+  end
+end

data/spec/unit/ruby_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Command, '#ruby' do
+  it "runs ruby with a single string argument" do
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+    out, err = cmd.ruby %q{-e "puts 'Hello World'"}
+    expect(out.chomp).to eq("Hello World")
+    expect(err).to be_empty unless jruby?
+  end
+
+  it "runs ruby with multiple arguments" do
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+    result = double(:success? => true)
+    allow(cmd).to receive(:run).with(TTY::Command::RUBY,
+      'script.rb', 'foo', 'bar', {}).and_return(result)
+    expect(cmd.ruby('script.rb', 'foo', 'bar')).to eq(result)
+  end
+end

data/spec/unit/run_spec.rb

@@ -0,0 +1,161 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Command, '#run' do
+  it 'runs command and prints to stdout' do
+    output = StringIO.new
+    command = TTY::Command.new(output: output)
+
+    out, err = command.run(:echo, 'hello')
+
+    expect(out.chomp).to eq("hello")
+    expect(err).to eq("")
+  end
+
+  it 'runs command successfully with logging' do
+    output = StringIO.new
+    uuid= 'xxxx'
+    allow(SecureRandom).to receive(:uuid).and_return(uuid)
+    command = TTY::Command.new(output: output)
+
+    command.run(:echo, 'hello')
+
+    output.rewind
+    lines = output.readlines
+    lines.last.gsub!(/\d+\.\d+/, 'x')
+    expect(lines).to eq([
+      "[\e[32m#{uuid}\e[0m] Running \e[33;1mecho hello\e[0m\n",
+      "[\e[32m#{uuid}\e[0m] \thello\n",
+      "[\e[32m#{uuid}\e[0m] Finished in x seconds with exit status 0 (\e[32;1msuccessful\e[0m)\n"
+    ])
+  end
+
+  it 'runs command successfully with logging without color' do
+    output = StringIO.new
+    uuid= 'xxxx'
+    allow(SecureRandom).to receive(:uuid).and_return(uuid)
+    command = TTY::Command.new(output: output, color: false)
+
+    command.run(:echo, 'hello')
+
+    output.rewind
+    lines = output.readlines
+    lines.last.gsub!(/\d+\.\d+/, 'x')
+    expect(lines).to eq([
+      "[#{uuid}] Running echo hello\n",
+      "[#{uuid}] \thello\n",
+      "[#{uuid}] Finished in x seconds with exit status 0 (successful)\n"
+    ])
+  end
+
+  it 'runs command successfully with logging without uuid set globally' do
+    output = StringIO.new
+    command = TTY::Command.new(output: output, uuid: false)
+
+    command.run(:echo, 'hello')
+    output.rewind
+
+    lines = output.readlines
+    lines.last.gsub!(/\d+\.\d+/, 'x')
+    expect(lines).to eq([
+      "Running \e[33;1mecho hello\e[0m\n",
+      "\thello\n",
+      "Finished in x seconds with exit status 0 (\e[32;1msuccessful\e[0m)\n"
+    ])
+  end
+
+  it 'runs command successfully with logging without uuid set locally' do
+    output = StringIO.new
+    command = TTY::Command.new(output: output)
+
+    command.run(:echo, 'hello', uuid: false)
+    output.rewind
+
+    lines = output.readlines
+    lines.last.gsub!(/\d+\.\d+/, 'x')
+    expect(lines).to eq([
+      "Running \e[33;1mecho hello\e[0m\n",
+      "\thello\n",
+      "Finished in x seconds with exit status 0 (\e[32;1msuccessful\e[0m)\n"
+    ])
+  end
+
+  it "runs command and fails with logging" do
+    non_zero_exit = fixtures_path('non_zero_exit')
+    output = StringIO.new
+    uuid= 'xxxx'
+    allow(SecureRandom).to receive(:uuid).and_return(uuid)
+    command = TTY::Command.new(output: output)
+
+    command.run!("ruby #{non_zero_exit}")
+
+    output.rewind
+    lines = output.readlines
+    lines.last.gsub!(/\d+\.\d+/, 'x')
+    expect(lines).to eq([
+      "[\e[32m#{uuid}\e[0m] Running \e[33;1mruby #{non_zero_exit}\e[0m\n",
+      "[\e[32m#{uuid}\e[0m] \tnooo\n",
+      "[\e[32m#{uuid}\e[0m] Finished in x seconds with exit status 1 (\e[31;1mfailed\e[0m)\n"
+    ])
+  end
+
+  it "raises ExitError on command failure" do
+    non_zero_exit = fixtures_path('non_zero_exit')
+    output = StringIO.new
+    command = TTY::Command.new(output: output)
+
+    expect {
+      command.run("ruby #{non_zero_exit}")
+    }.to raise_error(TTY::Command::ExitError,
+      ["Running `ruby #{non_zero_exit}` failed with",
+       "  exit status: 1",
+       "  stdout: nooo",
+       "  stderr: Nothing written\n"].join("\n")
+    )
+  end
+
+  it "streams output data" do
+    stream = fixtures_path('stream')
+    out_stream = StringIO.new
+    command = TTY::Command.new(output: out_stream)
+    output = ''
+    error = ''
+    command.run("ruby #{stream}") do |out, err|
+     output << out if out
+     error << err if err
+    end
+    expect(output.gsub(/\r\n|\n/,'')).to eq("hello 1hello 2hello 3")
+    expect(error).to eq('')
+  end
+
+  it "preserves ANSI codes" do
+    output = StringIO.new
+    command = TTY::Command.new(output: output, printer: :quiet)
+
+    out, _ = command.run("echo \e[35mhello\e[0m")
+
+    expect(out.chomp).to eq("\e[35mhello\e[0m")
+    expect(output.string.chomp).to eq("\e[35mhello\e[0m")
+  end
+
+  it "logs phased output in one line" do
+    phased_output = fixtures_path('phased_output')
+    uuid= 'xxxx'
+    allow(SecureRandom).to receive(:uuid).and_return(uuid)
+    output = StringIO.new
+    cmd = TTY::Command.new(output: output)
+
+    out, err = cmd.run("ruby #{phased_output}")
+
+    expect(out).to eq('.' * 10)
+    expect(err).to eq('')
+
+    output.rewind
+    lines = output.readlines
+    lines.last.gsub!(/\d+\.\d+/, 'x')
+    expect(lines).to eq([
+      "[\e[32m#{uuid}\e[0m] Running \e[33;1mruby #{phased_output}\e[0m\n",
+      "[\e[32m#{uuid}\e[0m] \t..........\n",
+      "[\e[32m#{uuid}\e[0m] Finished in x seconds with exit status 0 (\e[32;1msuccessful\e[0m)\n"
+    ])
+  end
+end