ronin 1.5.1 → 2.0.0.beta1

data/spec/cli/commands/unescape_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'ronin/cli/commands/unescape'
+
+describe Ronin::CLI::Commands::Unescape do
+  describe "options" do
+    before { subject.parse_options(argv) }
+
+    describe "--c" do
+      let(:argv) { %w[--c] }
+
+      it "must require 'ronin/support/encoding/c'" do
+        expect(require 'ronin/support/encoding/c').to be(false)
+      end
+
+      it "must add :c_unescape to #method_calls" do
+        expect(subject.method_calls.last).to eq(:c_unescape)
+      end
+    end
+
+    describe "--hex" do
+      let(:argv) { %w[--hex] }
+
+      it "must require 'ronin/support/encoding/hex'" do
+        expect(require 'ronin/support/encoding/hex').to be(false)
+      end
+
+      it "must add :hex_unescape to #method_calls" do
+        expect(subject.method_calls.last).to eq(:hex_unescape)
+      end
+    end
+
+    describe "--html" do
+      let(:argv) { %w[--html] }
+
+      it "must require 'ronin/support/encoding/html'" do
+        expect(require 'ronin/support/encoding/html').to be(false)
+      end
+
+      it "must add :html_unescape to #method_calls" do
+        expect(subject.method_calls.last).to eq(:html_unescape)
+      end
+    end
+
+    describe "--uri" do
+      let(:argv) { %w[--uri] }
+
+      it "must require 'ronin/support/encoding/uri'" do
+        expect(require 'ronin/support/encoding/uri').to be(false)
+      end
+
+      it "must add :uri_unescape to #method_calls" do
+        expect(subject.method_calls.last).to eq(:uri_unescape)
+      end
+    end
+
+    describe "--http" do
+      let(:argv) { %w[--http] }
+
+      it "must require 'ronin/support/encoding/http'" do
+        expect(require 'ronin/support/encoding/http').to be(false)
+      end
+
+      it "must add :http_unescape to #method_calls" do
+        expect(subject.method_calls.last).to eq(:http_unescape)
+      end
+    end
+
+    describe "--js" do
+      let(:argv) { %w[--js] }
+
+      it "must require 'ronin/support/encoding/js'" do
+        expect(require 'ronin/support/encoding/js').to be(false)
+      end
+
+      it "must add :js_unescape to #method_calls" do
+        expect(subject.method_calls.last).to eq(:js_unescape)
+      end
+    end
+
+    describe "--shell" do
+      let(:argv) { %w[--shell] }
+
+      it "must require 'ronin/support/encoding/shell'" do
+        expect(require 'ronin/support/encoding/shell').to be(false)
+      end
+
+      it "must add :shell_unescape to #method_calls" do
+        expect(subject.method_calls.last).to eq(:shell_unescape)
+      end
+    end
+
+    describe "--powershell" do
+      let(:argv) { %w[--powershell] }
+
+      it "must require 'ronin/support/encoding/powershell'" do
+        expect(require 'ronin/support/encoding/powershell').to be(false)
+      end
+
+      it "must add :powershell_unescape to #method_calls" do
+        expect(subject.method_calls.last).to eq(:powershell_unescape)
+      end
+    end
+
+    describe "--xml" do
+      let(:argv) { %w[--xml] }
+
+      it "must require 'ronin/support/encoding/xml'" do
+        expect(require 'ronin/support/encoding/xml').to be(false)
+      end
+
+      it "must add :xml_unescape to #method_calls" do
+        expect(subject.method_calls.last).to eq(:xml_unescape)
+      end
+    end
+
+    describe "--ruby" do
+      let(:argv) { %w[--ruby] }
+
+      it "must require 'ronin/support/encoding/ruby'" do
+        expect(require 'ronin/support/encoding/ruby').to be(false)
+      end
+
+      it "must add :ruby_unescape to #method_calls" do
+        expect(subject.method_calls.last).to eq(:ruby_unescape)
+      end
+    end
+  end
+end

data/spec/cli/commands/unquote_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'ronin/cli/commands/unquote'
+
+describe Ronin::CLI::Commands::Unquote do
+  describe "options" do
+    before { subject.parse_options(argv) }
+
+    describe "--c" do
+      let(:argv) { %w[--c] }
+
+      it "must require 'ronin/support/encoding/c'" do
+        expect(require 'ronin/support/encoding/c').to be(false)
+      end
+
+      it "must add :c_unquote to #method_calls" do
+        expect(subject.method_calls.last).to eq(:c_unquote)
+      end
+    end
+
+    describe "--hex" do
+      let(:argv) { %w[--hex] }
+
+      it "must require 'ronin/support/encoding/hex'" do
+        expect(require 'ronin/support/encoding/hex').to be(false)
+      end
+
+      it "must add :hex_unquote to #method_calls" do
+        expect(subject.method_calls.last).to eq(:hex_unquote)
+      end
+    end
+
+    describe "--js" do
+      let(:argv) { %w[--js] }
+
+      it "must require 'ronin/support/encoding/js'" do
+        expect(require 'ronin/support/encoding/js').to be(false)
+      end
+
+      it "must add :js_unquote to #method_calls" do
+        expect(subject.method_calls.last).to eq(:js_unquote)
+      end
+    end
+
+    describe "--shell" do
+      let(:argv) { %w[--shell] }
+
+      it "must require 'ronin/support/encoding/shell'" do
+        expect(require 'ronin/support/encoding/shell').to be(false)
+      end
+
+      it "must add :shell_unquote to #method_calls" do
+        expect(subject.method_calls.last).to eq(:shell_unquote)
+      end
+    end
+
+    describe "--powershell" do
+      let(:argv) { %w[--powershell] }
+
+      it "must require 'ronin/support/encoding/powershell'" do
+        expect(require 'ronin/support/encoding/powershell').to be(false)
+      end
+
+      it "must add :powershell_unquote to #method_calls" do
+        expect(subject.method_calls.last).to eq(:powershell_unquote)
+      end
+    end
+
+    describe "--ruby" do
+      let(:argv) { %w[--ruby] }
+
+      it "must require 'ronin/support/encoding/ruby'" do
+        expect(require 'ronin/support/encoding/ruby').to be(false)
+      end
+
+      it "must add :ruby_unquote to #method_calls" do
+        expect(subject.method_calls.last).to eq(:ruby_unquote)
+      end
+    end
+  end
+end

data/spec/cli/fixtures/file.txt

@@ -0,0 +1,3 @@
+foo
+bar
+baz

data/spec/cli/fixtures/file2.txt

@@ -0,0 +1,3 @@
+qux
+quux
+corge

data/spec/cli/key_options_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'ronin/cli/key_options'
+require 'ronin/cli/command'
+
+describe Ronin::CLI::KeyOptions do
+  module TestKeyOptions
+    class TestCommand < Ronin::CLI::Command
+      include Ronin::CLI::KeyOptions
+    end
+  end
+
+  let(:test_class) { TestKeyOptions::TestCommand }
+  subject { test_class.new }
+
+  describe ".included" do
+    subject { test_class }
+
+    it "must define a --key option" do
+      expect(subject.options[:key]).to be_kind_of(CommandKit::Options::Option)
+      expect(subject.options[:key].short).to eq('-k')
+      expect(subject.options[:key].long).to eq('--key')
+      expect(subject.options[:key].desc).to eq("The key String")
+    end
+
+    it "must define a --key-file option" do
+      expect(subject.options[:key_file]).to be_kind_of(CommandKit::Options::Option)
+      expect(subject.options[:key_file].short).to eq('-K')
+      expect(subject.options[:key_file].long).to eq('--key-file')
+      expect(subject.options[:key_file].desc).to eq("The key file")
+    end
+  end
+
+  describe "options" do
+    before { subject.parse_options(argv) }
+
+    context "when the --key option is parsed" do
+      let(:key)  { 'foo' }
+      let(:argv) { ['--key', key] }
+
+      it "must set #key to the given argument" do
+        expect(subject.key).to eq(key)
+      end
+    end
+
+    context "when the --key-file option is parsed" do
+      let(:fixtures_dir) { File.join(__dir__,'fixtures') }
+      let(:key_file)     { File.join(fixtures_dir,'file.txt') }
+
+      let(:argv) { ['--key-file', key_file] }
+
+      it "must read the key file and set #key" do
+        expect(subject.key).to eq(File.binread(key_file))
+      end
+    end
+  end
+end

data/spec/cli/method_options_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'ronin/cli/method_options'
+require 'ronin/cli/command'
+
+describe Ronin::CLI::MethodOptions do
+  module TestMethodOptions
+    class TestCommand < Ronin::CLI::Command
+      include Ronin::CLI::MethodOptions
+    end
+  end
+
+  let(:test_class) { TestMethodOptions::TestCommand }
+  subject { test_class.new }
+
+  describe "#initialize" do
+    it "must initialize #methods_calls to an empty Array" do
+      expect(subject.method_calls).to eq([])
+    end
+  end
+
+  describe "#apply_method_options" do
+    let(:object) { 'hello world' }
+
+    before do
+      subject.method_calls << [:upcase]
+      subject.method_calls << [:reverse]
+    end
+
+    it "must apply all method options to the given String" do
+      expect(subject.apply_method_options(object)).to eq("DLROW OLLEH")
+    end
+
+    context "when #method_calls contains an entry with arguments" do
+      before do
+        subject.method_calls << [:slice, [0, 5]]
+      end
+
+      it "must call that method with the given arguments Array" do
+        expect(subject.apply_method_options(object)).to eq("DLROW")
+      end
+    end
+
+    context "when #method_calls contains a private method" do
+      let(:method_name) { :puts }
+
+      before do
+        subject.method_calls << [method_name, "shouldn't print this"]
+      end
+
+      it do
+        expect {
+          subject.apply_method_options(object)
+        }.to raise_error(ArgumentError,"cannot call method Object##{method_name} on object \"DLROW OLLEH\"")
+      end
+    end
+
+    context "when #method_calls contains a method inherited from Object" do
+      let(:method_name) { :instance_eval }
+
+      before do
+        subject.method_calls << [method_name, "1 + 1"]
+      end
+
+      it do
+        expect {
+          subject.apply_method_options(object)
+        }.to raise_error(ArgumentError,"cannot call method Object##{method_name} on object \"DLROW OLLEH\"")
+      end
+    end
+  end
+end

data/spec/cli/string_methods_command_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'ronin/cli/string_methods_command'
+
+describe Ronin::CLI::StringMethodsCommand do
+  module TestStringMethodsCommand
+    class TestCommand < Ronin::CLI::StringMethodsCommand
+    end
+  end
+
+  let(:test_class) { TestStringMethodsCommand::TestCommand }
+  subject { test_class.new }
+
+  describe "#process_string" do
+    let(:string) { 'hello world' }
+
+    before do
+      subject.method_calls << [:upcase]
+      subject.method_calls << [:reverse]
+    end
+
+    it "must apply all method options to the given String" do
+      expect(subject.process_string(string)).to eq("DLROW OLLEH")
+    end
+  end
+end

data/spec/cli/string_processor_command_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+require 'ronin/cli/string_processor_command'
+
+describe Ronin::CLI::StringProcessorCommand do
+  module TestStringProcessorCommand
+    class TestCommand < Ronin::CLI::StringProcessorCommand
+
+      def process_string(string)
+        string.reverse
+      end
+
+    end
+  end
+
+  let(:test_class) { TestStringProcessorCommand::TestCommand }
+  subject { test_class.new }
+
+  describe described_class::StringValue do
+    let(:string) { "foo" }
+
+    subject { described_class.new(string) }
+
+    describe "#initialize" do
+      it "must set #string" do
+        expect(subject.string).to eq(string)
+      end
+    end
+  end
+
+  describe described_class::FileValue do
+    let(:file) { "file.txt" }
+
+    subject { described_class.new(file) }
+
+    describe "#initialize" do
+      it "must set #file" do
+        expect(subject.file).to eq(file)
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "must initialize #input_values to an empty Array" do
+      expect(subject.input_values).to eq([])
+    end
+  end
+
+  describe "options" do
+    describe "--string" do
+      let(:string1) { "foo" }
+      let(:string2) { "bar" }
+      let(:argv)    { ['--string', string1, '--string', string2] }
+
+      before { subject.parse_options(argv) }
+
+      it "must append a #{described_class}::StringValue to #input_values" do
+        expect(subject.input_values.length).to eq(2)
+
+        expect(subject.input_values[0]).to be_kind_of(described_class::StringValue)
+        expect(subject.input_values[0].string).to eq(string1)
+
+        expect(subject.input_values[1]).to be_kind_of(described_class::StringValue)
+        expect(subject.input_values[1].string).to eq(string2)
+      end
+    end
+
+    describe "--file" do
+      let(:file1) { "foo" }
+      let(:file2) { "bar" }
+      let(:argv)  { ['--file', file1, '--file', file2] }
+
+      before { subject.parse_options(argv) }
+
+      it "must append a #{described_class}::FileValue to #input_values" do
+        expect(subject.input_values.length).to eq(2)
+
+        expect(subject.input_values[0]).to be_kind_of(described_class::FileValue)
+        expect(subject.input_values[0].file).to eq(file1)
+
+        expect(subject.input_values[1]).to be_kind_of(described_class::FileValue)
+        expect(subject.input_values[1].file).to eq(file2)
+      end
+    end
+  end
+
+  let(:fixtures_dir) { File.join(__dir__,'fixtures') }
+  let(:file)         { File.join(fixtures_dir,'file.txt') }
+  let(:file2)        { File.join(fixtures_dir,'file2.txt') }
+
+  describe "#run" do
+    context "when arguments are given" do
+      let(:args) { [file, file2] }
+
+      let(:expected_values) { [File.read(file), File.read(file2)] }
+      let(:expected_output) do
+        expected_values.map(&:reverse).join($/) + $/
+      end
+
+      it "must read and process each argument as a file in full" do
+        expect {
+          subject.run(*args)
+        }.to output(expected_output).to_stdout
+      end
+
+      context "and when --file or --string options are given" do
+        let(:string) { "abc" }
+        let(:argv)   { ['--string', string, '--file', file] }
+
+        before { subject.parse_options(argv) }
+
+        let(:expected_values) do
+          [string, File.read(file)] + args.map { |path| File.read(path) }
+        end
+        let(:expected_output) do
+          expected_values.map(&:reverse).join($/) + $/
+        end
+
+        it "must process the input from the --file and --string options then read and process the arguments" do
+          expect {
+            subject.run(*args)
+          }.to output(expected_output).to_stdout
+        end
+      end
+    end
+
+    context "when no arguments are given" do
+      context "but --file or --string options are given" do
+        let(:string) { "abc" }
+        let(:argv)   { ['--string', string, '--file', file] }
+
+        before { subject.parse_options(argv) }
+
+        let(:expected_values) { [string, File.read(file)] }
+        let(:expected_output) do
+          expected_values.map(&:reverse).join($/) + $/
+        end
+
+        it "must process the input from the --file and --string options in the order given" do
+          expect {
+            subject.run()
+          }.to output(expected_output).to_stdout
+        end
+      end
+
+      context "and no options were given" do
+        let(:expected_output) { File.read(file).reverse + $/ }
+
+        let(:stdin) { File.open(file) }
+        subject { test_class.new(stdin: stdin) }
+
+        it "must read and process input from stdin in full" do
+          expect {
+            subject.run()
+          }.to output(expected_output).to_stdout
+        end
+      end
+    end
+  end
+
+  describe "#open_file" do
+    let(:path) { __FILE__ }
+
+    context "when given a block" do
+      it "must yield the newly opened File" do
+        expect { |b|
+          subject.open_file(path,&b)
+        }.to yield_with_args(File)
+      end
+
+      it "must open the file in non-binary mode by default" do
+        file_binmode = nil
+
+        subject.open_file(path) do |file|
+          file_binmode = file.binmode?
+        end
+
+        expect(file_binmode).to be(false)
+      end
+    end
+
+    context "when no block is given" do
+      it "must return the opened File" do
+        file = subject.open_file(path)
+
+        expect(file).to be_kind_of(File)
+        expect(file.path).to eq(path)
+      end
+
+      it "must open the file in non-binary mode by default" do
+        file = subject.open_file(path)
+
+        expect(file.binmode?).to be(false)
+      end
+    end
+  end
+
+  describe "#process_input" do
+    let(:input) { File.open(file) }
+    let(:expected_output) { File.read(file).reverse + $/ }
+
+    it "must read the input stream and process the full String" do
+      expect {
+        subject.process_input(input)
+      }.to output(expected_output).to_stdout
+    end
+
+    context "when the --multiline option is given" do
+      let(:argv) { %w[--multiline] }
+      let(:expected_output) do
+        File.readlines(file, chomp: true).map(&:reverse).join($/) + $/
+      end
+
+      before { subject.parse_options(argv) }
+
+      it "must read and process each line of the input" do
+        expect {
+          subject.process_input(input)
+        }.to output(expected_output).to_stdout
+      end
+
+      context "and the --keep-newlines option is given" do
+        let(:argv) { %w[--multiline --keep-newlines] }
+
+        let(:expected_output) do
+          File.readlines(file).map(&:reverse).join($/) + $/
+        end
+
+        it "must not omit the newline character at the end of each line" do
+          expect {
+            subject.process_input(input)
+          }.to output(expected_output).to_stdout
+        end
+      end
+    end
+  end
+
+  describe "#process_string" do
+    subject { described_class.new }
+
+    let(:string) { "foo" }
+
+    it do
+      expect {
+        subject.process_string(string)
+      }.to raise_error(NotImplementedError,"#{subject.class}#process_string method was not implemented")
+    end
+  end
+
+  describe "#print_string" do
+    let(:string) { "hello world" }
+
+    it "must print the string using #puts" do
+      expect(subject).to receive(:puts).with(string)
+
+      subject.print_string(string)
+    end
+  end
+end