wordlist 0.1.1 → 1.0.1

data/spec/cli_spec.rb

@@ -0,0 +1,802 @@
+require 'spec_helper'
+require 'wordlist/cli'
+
+describe Wordlist::CLI do
+  describe "#initialize" do
+    it "must default #mode to :read" do
+      expect(subject.mode).to eq(:read)
+    end
+
+    it "must default #format to nil" do
+      expect(subject.format).to be(nil)
+    end
+
+    it "must default #command to nil" do
+      expect(subject.command).to be(nil)
+    end
+
+    it "must default #output to nil" do
+      expect(subject.output).to be(nil)
+    end
+
+    it "must initialize #option_parser" do
+      expect(subject.option_parser).to be_kind_of(OptionParser)
+    end
+
+    it "must initialize #operators to []" do
+      expect(subject.operators).to eq([])
+    end
+
+    it "must initialize #modifiers to []" do
+      expect(subject.modifiers).to eq([])
+    end
+
+    it "must initialize #build_options to {}" do
+      expect(subject.builder_options).to eq({})
+    end
+  end
+
+  describe "#print_error" do
+    let(:error) { "error!" }
+
+    it "must print the program name and the error message to stderr" do
+      expect {
+        subject.print_error(error)
+      }.to output("#{described_class::PROGRAM_NAME}: #{error}#{$/}").to_stderr
+    end
+  end
+
+  describe "#print_backtrace" do
+    let(:exception) { RuntimeError.new("error!") }
+
+    it "must print the program name and the error message to stderr" do
+      expect {
+        subject.print_backtrace(exception)
+      }.to output(
+        %r{Oops! Looks like you've found a bug!
+Please report the following text to: #{Regexp.escape(described_class::BUG_REPORT_URL)}
+
+```}m
+      ).to_stderr
+    end
+  end
+
+  let(:fixtures_dir) { File.join(__dir__,'fixtures') }
+
+  describe "#open_wordlist" do
+    context "when #format is set" do
+      let(:format) { :gzip }
+      let(:path)   { ::File.join(fixtures_dir,'wordlist_with_ambiguous_format') }
+
+      subject { described_class.new(format: format) }
+
+      it "must call Wordlist::File.new with a format: keyword argument" do
+        wordlist = subject.open_wordlist(path)
+
+        expect(wordlist.format).to be(format)
+      end
+    end
+
+    context "when #format is not set" do
+      let(:path) { ::File.join(fixtures_dir,'wordlist.txt.gz') }
+
+      it "must let Wordlist::File.new infer the format" do
+        wordlist = subject.open_wordlist(path)
+
+        expect(wordlist.format).to be(:gzip)
+      end
+
+      context "and the file's format cannot be inferred" do
+        let(:path)   { ::File.join(fixtures_dir,'wordlist_with_ambiguous_format') }
+
+        it "must print an error and exit with -1" do
+          expect(subject).to receive(:exit).with(-1)
+
+          expect {
+            subject.open_wordlist(path)
+          }.to output("#{described_class::PROGRAM_NAME}: could not infer the format of file: #{path.inspect}#{$/}").to_stderr
+        end
+      end
+    end
+
+    context "when the file does not exist" do
+      let(:path)          { 'does/not/exist.txt'   }
+      let(:absolute_path) { File.expand_path(path) }
+
+      it "must print an error and exit with -1" do
+        expect(subject).to receive(:exit).with(-1)
+
+        expect {
+          subject.open_wordlist(path)
+        }.to output("#{described_class::PROGRAM_NAME}: wordlist file does not exist: #{absolute_path.inspect}#{$/}").to_stderr
+      end
+    end
+  end
+
+  describe "#add_operator" do
+    let(:op1) { :+ }
+    let(:wordlist1) { double(:other_wordlist1) }
+
+    let(:op2) { :* }
+    let(:wordlist2) { double(:other_wordlist2) }
+
+    before do
+      subject.add_operator(op1, wordlist1)
+      subject.add_operator(op2, wordlist2)
+    end
+
+    it "must append an operator and it's arguments to #operators" do
+      expect(subject.operators[0]).to be_a(Array)
+      expect(subject.operators[0][0]).to eq(op1)
+      expect(subject.operators[0][1]).to eq([wordlist1])
+
+      expect(subject.operators[1]).to be_a(Array)
+      expect(subject.operators[1][0]).to eq(op2)
+      expect(subject.operators[1][1]).to eq([wordlist2])
+    end
+  end
+
+  describe "#add_modifier" do
+    let(:mod1)  { :capitalize }
+    let(:args1) { [] }
+
+    let(:mod2)  { :gsub }
+    let(:args2) { ['e','3'] }
+
+    before do
+      subject.add_modifier(mod1, *args1)
+      subject.add_modifier(mod2, *args2)
+    end
+
+    it "must append an modifier and it's arguments to #modifiers" do
+      expect(subject.modifiers[0]).to be_a(Array)
+      expect(subject.modifiers[0][0]).to eq(mod1)
+      expect(subject.modifiers[0][1]).to eq(args1)
+
+      expect(subject.modifiers[1]).to be_a(Array)
+      expect(subject.modifiers[1][0]).to eq(mod2)
+      expect(subject.modifiers[1][1]).to eq(args2)
+    end
+  end
+
+  describe "#option_parser" do
+    it do
+      expect(subject.option_parser).to be_kind_of(OptionParser)
+    end
+
+    describe "#parse" do
+      context "when given -f FORMAT" do
+        let(:format) { :gzip }
+        let(:argv)   { ['-f', format.to_s] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #format" do
+          expect(subject.format).to eq(format)
+        end
+      end
+
+      context "when given --format FORMAT" do
+        let(:format) { :gzip }
+        let(:argv)   { ['--format', format.to_s] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #format" do
+          expect(subject.format).to eq(format)
+        end
+      end
+
+      context "when given --exec COMMAND" do
+        let(:command) { "foo {}" }
+        let(:argv)    { ['--exec', command] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #command" do
+          expect(subject.command).to eq(command)
+        end
+      end
+
+      %w[-U --union].each do |flag|
+        context "when given #{flag} WORDLIST" do
+          let(:wordlist) { File.join(fixtures_dir,'wordlist.txt.gz') }
+          let(:argv)     { [flag, wordlist] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #operators" do
+            expect(subject.operators.length).to be(1)
+            expect(subject.operators[0][0]).to be(:|)
+            expect(subject.operators[0][1].length).to be(1)
+            expect(subject.operators[0][1][0]).to be_kind_of(Wordlist::File)
+            expect(subject.operators[0][1][0].path).to eq(wordlist)
+          end
+        end
+      end
+
+      %w[-I --intersect].each do |flag|
+        context "when given #{flag} WORDLIST" do
+          let(:wordlist) { File.join(fixtures_dir,'wordlist.txt.gz') }
+          let(:argv)     { [flag, wordlist] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #operators" do
+            expect(subject.operators.length).to be(1)
+            expect(subject.operators[0][0]).to be(:&)
+            expect(subject.operators[0][1].length).to be(1)
+            expect(subject.operators[0][1][0]).to be_kind_of(Wordlist::File)
+            expect(subject.operators[0][1][0].path).to eq(wordlist)
+          end
+        end
+      end
+
+      %w[-S --subtract].each do |flag|
+        context "when given #{flag} WORDLIST" do
+          let(:wordlist) { File.join(fixtures_dir,'wordlist.txt.gz') }
+          let(:argv)     { [flag, wordlist] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #operators" do
+            expect(subject.operators.length).to be(1)
+            expect(subject.operators[0][0]).to be(:-)
+            expect(subject.operators[0][1].length).to be(1)
+            expect(subject.operators[0][1][0]).to be_kind_of(Wordlist::File)
+            expect(subject.operators[0][1][0].path).to eq(wordlist)
+          end
+        end
+      end
+
+      %w[-p --product].each do |flag|
+        context "when given #{flag} WORDLIST" do
+          let(:wordlist) { File.join(fixtures_dir,'wordlist.txt.gz') }
+          let(:argv)     { [flag, wordlist] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #operators" do
+            expect(subject.operators.length).to be(1)
+            expect(subject.operators[0][0]).to be(:*)
+            expect(subject.operators[0][1].length).to be(1)
+            expect(subject.operators[0][1][0]).to be_kind_of(Wordlist::File)
+            expect(subject.operators[0][1][0].path).to eq(wordlist)
+          end
+        end
+      end
+
+      %w[-P --power].each do |flag|
+        context "when given #{flag} POWER" do
+          let(:power) { 3 }
+          let(:argv)  { [flag, power.to_s] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #operators" do
+            expect(subject.operators.length).to be(1)
+            expect(subject.operators[0][0]).to be(:**)
+            expect(subject.operators[0][1].length).to be(1)
+            expect(subject.operators[0][1][0]).to be(power)
+          end
+        end
+      end
+
+      %w[-u --unique].each do |flag|
+        context "when given #{flag}" do
+          let(:argv) { [flag] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #operators" do
+            expect(subject.operators.length).to be(1)
+            expect(subject.operators[0][0]).to be(:uniq)
+            expect(subject.operators[0][1].length).to be(0)
+          end
+        end
+      end
+
+      %w[-C --capitalize].each do |flag|
+        context "when given #{flag}" do
+          let(:argv) { [flag] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #modifiers" do
+            expect(subject.modifiers.length).to be(1)
+            expect(subject.modifiers[0][0]).to be(:capitalize)
+            expect(subject.modifiers[0][1].length).to be(0)
+          end
+        end
+      end
+
+      %w[--uppercase --upcase].each do |flag|
+        context "when given #{flag} WORDLIST" do
+          let(:wordlist) { File.join(fixtures_dir,'wordlist.txt.gz') }
+          let(:argv)     { [flag, wordlist] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #modifiers" do
+            expect(subject.modifiers.length).to be(1)
+            expect(subject.modifiers[0][0]).to be(:upcase)
+            expect(subject.modifiers[0][1].length).to be(0)
+          end
+        end
+      end
+
+      %w[--lowercase --downcase].each do |flag|
+        context "when given #{flag} WORDLIST" do
+          let(:wordlist) { File.join(fixtures_dir,'wordlist.txt.gz') }
+          let(:argv)     { [flag, wordlist] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #modifiers" do
+            expect(subject.modifiers.length).to be(1)
+            expect(subject.modifiers[0][0]).to be(:downcase)
+            expect(subject.modifiers[0][1].length).to be(0)
+          end
+        end
+      end
+
+      %w[-t --tr].each do |flag|
+        context "when given #{flag} CHARS:REPLACE" do
+          let(:chars)   { 'e' }
+          let(:replace) { '3' }
+          let(:argv)    { [flag, "#{chars}:#{replace}"] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #modifiers" do
+            expect(subject.modifiers.length).to be(1)
+            expect(subject.modifiers[0][0]).to be(:tr)
+            expect(subject.modifiers[0][1].length).to be(2)
+            expect(subject.modifiers[0][1][0]).to eq(chars)
+            expect(subject.modifiers[0][1][1]).to eq(replace)
+          end
+        end
+      end
+
+      %w[-s --sub].each do |flag|
+        context "when given #{flag} CHARS:REPLACE" do
+          let(:chars)   { 'e' }
+          let(:replace) { '3' }
+          let(:argv)    { [flag, "#{chars}:#{replace}"] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #modifiers" do
+            expect(subject.modifiers.length).to be(1)
+            expect(subject.modifiers[0][0]).to be(:sub)
+            expect(subject.modifiers[0][1].length).to be(2)
+            expect(subject.modifiers[0][1][0]).to eq(chars)
+            expect(subject.modifiers[0][1][1]).to eq(replace)
+          end
+        end
+      end
+
+      %w[-g --gsub].each do |flag|
+        context "when given #{flag} CHARS:REPLACE" do
+          let(:chars)   { 'e' }
+          let(:replace) { '3' }
+          let(:argv)    { [flag, "#{chars}:#{replace}"] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #modifiers" do
+            expect(subject.modifiers.length).to be(1)
+            expect(subject.modifiers[0][0]).to be(:gsub)
+            expect(subject.modifiers[0][1].length).to be(2)
+            expect(subject.modifiers[0][1][0]).to eq(chars)
+            expect(subject.modifiers[0][1][1]).to eq(replace)
+          end
+        end
+      end
+
+      %w[-m --mutate].each do |flag|
+        context "when given #{flag} CHARS:REPLACE" do
+          let(:chars)   { 'e' }
+          let(:replace) { '3' }
+          let(:argv)    { [flag, "#{chars}:#{replace}"] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #modifiers" do
+            expect(subject.modifiers.length).to be(1)
+            expect(subject.modifiers[0][0]).to be(:mutate)
+            expect(subject.modifiers[0][1].length).to be(2)
+            expect(subject.modifiers[0][1][0]).to eq(chars)
+            expect(subject.modifiers[0][1][1]).to eq(replace)
+          end
+        end
+      end
+
+      %w[-M --mutate-case].each do |flag|
+        context "when given #{flag}" do
+          let(:argv) { [flag] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #modifiers" do
+            expect(subject.modifiers.length).to be(1)
+            expect(subject.modifiers[0][0]).to be(:mutate_case)
+            expect(subject.modifiers[0][1].length).to be(0)
+          end
+        end
+      end
+
+      %w[-b --build].each do |flag|
+        context "when given #{flag} WORDLIST" do
+          let(:wordlist) { File.join(fixtures_dir,'new_wordlist.txt') }
+          let(:argv)     { [flag, wordlist] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must append to #modifiers" do
+            expect(subject.mode).to eq(:build)
+            expect(subject.output).to eq(wordlist)
+          end
+        end
+      end
+
+      %w[-a --append].each do |flag|
+        context "when given #{flag}" do
+          let(:argv) { [flag] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must set #builder_options[:append] to true" do
+            expect(subject.builder_options[:append]).to be(true)
+          end
+
+          context "and when given --no-append" do
+            let(:argv) { ['--append', '--no-append'] }
+
+            it "must set #builder_options[:append] to false" do
+              expect(subject.builder_options[:append]).to be(false)
+            end
+          end
+        end
+      end
+
+      %w[-L --lang].each do |flag|
+        context "when given #{flag} LANG" do
+          let(:lang) { 'fr' }
+          let(:argv) { [flag, lang] }
+
+          before { subject.option_parser.parse(argv) }
+
+          it "must set #builder_options[:lang] to LANG" do
+            expect(subject.builder_options[:lang]).to eq(lang)
+          end
+        end
+      end
+
+      context "when given --stop-words \"WORDS...\"" do
+        let(:words) { "foo bar baz" }
+        let(:argv)  { ['--stop-words', words] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #builder_options[:stop_words] to the Array of WORDS" do
+          expect(subject.builder_options[:stop_words]).to eq(words.split)
+        end
+      end
+
+      context "when given --ignore-words \"WORDS...\"" do
+        let(:words) { "foo bar baz" }
+        let(:argv)  { ['--ignore-words', words] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #builder_options[:ignore_words] to the Array of WORDS" do
+          expect(subject.builder_options[:ignore_words]).to eq(words.split)
+        end
+      end
+
+      context "when given --digits" do
+        let(:argv) { ['--digits'] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #builder_options[:digits] to true" do
+          expect(subject.builder_options[:digits]).to be(true)
+        end
+
+        context "and when given --no-digits" do
+          let(:argv) { ['--digits', '--no-digits'] }
+
+          it "must set #builder_options[:digits] to false" do
+            expect(subject.builder_options[:digits]).to be(false)
+          end
+        end
+      end
+
+      context "when given --special-chars \"CHARS...\"" do
+        let(:chars) { "!@#$%^&*()_-" }
+        let(:argv)  { ['--special-chars', chars] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #builder_options[:special_chars] to the Array of CHARS" do
+          expect(subject.builder_options[:special_chars]).to eq(chars.chars)
+        end
+      end
+
+      context "when given --numbers" do
+        let(:argv) { ['--numbers'] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #builder_options[:numbers] to true" do
+          expect(subject.builder_options[:numbers]).to be(true)
+        end
+
+        context "and when given --no-numbers" do
+          let(:argv) { ['--numbers', '--no-numbers'] }
+
+          it "must set #builder_options[:numbers] to false" do
+            expect(subject.builder_options[:numbers]).to be(false)
+          end
+        end
+      end
+
+      context "when given --acronyms" do
+        let(:argv) { ['--acronyms'] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #builder_options[:acronyms] to true" do
+          expect(subject.builder_options[:acronyms]).to be(true)
+        end
+
+        context "and when given --no-acronyms" do
+          let(:argv) { ['--acronyms', '--no-acronyms'] }
+
+          it "must set #builder_options[:acronyms] to false" do
+            expect(subject.builder_options[:acronyms]).to be(false)
+          end
+        end
+      end
+
+      context "when given --normalize-case" do
+        let(:argv) { ['--normalize-case'] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #builder_options[:normalize_case] to true" do
+          expect(subject.builder_options[:normalize_case]).to be(true)
+        end
+
+        context "and when given --no-normalize-case" do
+          let(:argv) { ['--normalize-case', '--no-normalize-case'] }
+
+          it "must set #builder_options[:normalize_case] to false" do
+            expect(subject.builder_options[:normalize_case]).to be(false)
+          end
+        end
+      end
+
+      context "when given --normalize-apostrophes" do
+        let(:argv) { ['--normalize-apostrophes'] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #builder_options[:normalize_apostrophes] to true" do
+          expect(subject.builder_options[:normalize_apostrophes]).to be(true)
+        end
+
+        context "and when given --no-normalize-apostrophes" do
+          let(:argv) { ['--normalize-apostrophes', '--no-normalize-apostrophes'] }
+
+          it "must set #builder_options[:normalize_apostrophes] to false" do
+            expect(subject.builder_options[:normalize_apostrophes]).to be(false)
+          end
+        end
+      end
+
+      context "when given --normalize-acronyms" do
+        let(:argv) { ['--normalize-acronyms'] }
+
+        before { subject.option_parser.parse(argv) }
+
+        it "must set #builder_options[:normalize_acronyms] to true" do
+          expect(subject.builder_options[:normalize_acronyms]).to be(true)
+        end
+
+        context "and when given --no-normalize-acronyms" do
+          let(:argv) { ['--normalize-acronyms', '--no-normalize-acronyms'] }
+
+          it "must set #builder_options[:normalize_acronyms] to false" do
+            expect(subject.builder_options[:normalize_acronyms]).to be(false)
+          end
+        end
+      end
+
+      %w[-V --version].each do |flag|
+        context "when given #{flag}" do
+          let(:argv) { [flag] }
+
+          it "must print the program name and the Wordlist::VERSION" do
+            expect(subject).to receive(:exit)
+
+            expect {
+              subject.option_parser.parse(argv)
+            }.to output("#{described_class::PROGRAM_NAME} #{Wordlist::VERSION}#{$/}").to_stdout
+          end
+        end
+      end
+
+      %w[-h --help].each do |flag|
+        context "when given #{flag}" do
+          let(:argv) { [flag] }
+
+          it "must print the option paresr --help output" do
+            expect(subject).to receive(:exit)
+
+            expect {
+              subject.option_parser.parse(argv)
+            }.to output("#{subject.option_parser}").to_stdout
+          end
+        end
+      end
+    end
+  end
+
+  describe ".run" do
+    subject { described_class }
+
+    context "when Interrupt is raised" do
+      before do
+        expect_any_instance_of(described_class).to receive(:run).and_raise(Interrupt)
+      end
+
+      it "must exit with 130" do
+        expect(subject.run([])).to eq(130)
+      end
+    end
+
+    context "when Errno::EPIPE is raised" do
+      before do
+        expect_any_instance_of(described_class).to receive(:run).and_raise(Errno::EPIPE)
+      end
+
+      it "must exit with 0" do
+        expect(subject.run([])).to eq(0)
+      end
+    end
+  end
+
+  describe "#run" do
+    context "when given a wordlist file" do
+      let(:file) { ::File.join(fixtures_dir,'wordlist.txt') }
+      let(:argv) { [file] }
+
+      let(:expected_words) { File.readlines(file).map(&:chomp) }
+
+      it "must read each word from the file and print it to stdout" do
+        expect {
+          subject.run(argv)
+        }.to output(
+          expected_words.join($/) + $/
+        ).to_stdout
+      end
+
+      context "when also given the --exec COMMAND option" do
+        let(:command) { 'echo "WORD: {}"' }
+        let(:argv)    { ["--exec", command, file] }
+
+        let(:expected_output) do
+          expected_words.map do |word|
+          end
+        end
+
+        it "must execute the command with each word from the wordlist" do
+          expected_words.each do |word|
+            expect(subject).to receive(:system).with(command.sub('{}',word))
+          end
+
+          subject.run(argv)
+        end
+      end
+    end
+
+    context "when given the --build option" do
+      let(:expected_words) { %w[foo bar baz qux] }
+      let(:text) { (expected_words * 100).shuffle.join(' ') }
+
+      let(:output) { File.join(fixtures_dir,'new_wordlist.txt') }
+
+      context "and given one input file" do
+        let(:input) { File.join(fixtures_dir,"input_file.txt") }
+        let(:argv)  { ["--build", output, input] }
+
+        before { File.write(input,text) }
+
+        it "must build a new wordlist file based on the given file" do
+          subject.run(argv)
+
+          expect(File.readlines(output).map(&:chomp)).to match_array(expected_words)
+        end
+
+        after { FileUtils.rm_f(input) }
+      end
+
+      context "and given multiple input files" do
+        let(:words) { (expected_words * 100).shuffle }
+        let(:text1) { words[0,50]  }
+        let(:text2) { words[50,50] }
+
+        let(:input1) { File.join(fixtures_dir,"input_file1.txt") }
+        let(:input2) { File.join(fixtures_dir,"input_file2.txt") }
+        let(:argv)   { ["--build", output, input1, input2] }
+
+        before do
+          File.write(input1,text1)
+          File.write(input2,text2)
+        end
+
+        it "must build a new wordlist file based on the given files" do
+          subject.run(argv)
+
+          expect(File.readlines(output).map(&:chomp)).to match_array(expected_words)
+        end
+
+        after do
+          FileUtils.rm_f(input1)
+          FileUtils.rm_f(input2)
+        end
+      end
+
+      context "and given no input files" do
+        let(:argv) { ["--build", output] }
+
+        before do
+          $stdin = StringIO.new(text)
+        end
+
+        it "must build a new wordlist file by reading stdin" do
+          subject.run(argv)
+
+          expect(File.readlines(output).map(&:chomp)).to match_array(expected_words)
+        end
+
+        after do
+          $stdin = STDIN
+        end
+      end
+
+      after { FileUtils.rm_f(output) }
+    end
+
+    context "when an invalid option is given" do
+      let(:opt) { '--foo' }
+
+      it "must print 'wordlist: invalid option ...' to $stderr and exit with -1" do
+        expect {
+          expect(subject.run([opt])).to eq(-1)
+        }.to output("wordlist: invalid option: #{opt}#{$/}").to_stderr
+      end
+    end
+
+    context "when another type of Exception is raised" do
+      let(:exception) { RuntimeError.new("error!") }
+
+      before do
+        expect(subject).to receive(:read_mode).and_raise(exception)
+      end
+
+      it "must print a backtrace and exit with -1" do
+        expect {
+          expect(subject.run([])).to eq(-1)
+        }.to output(
+          %r{Oops! Looks like you've found a bug!
+Please report the following text to: #{Regexp.escape(described_class::BUG_REPORT_URL)}
+
+```}m
+        ).to_stderr
+      end
+    end
+  end
+end