ronin-payloads 0.1.0.beta1 → 0.1.1

data/spec/cli/encoder_methods_spec.rb

@@ -1,275 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/cli/encoder_methods'
-require 'ronin/payloads/cli/command'
-
-describe Ronin::Payloads::CLI::EncoderMethods do
-  module TestEncoderMethods
-    class TestCommand < Ronin::Payloads::CLI::Command
-      include Ronin::Payloads::CLI::EncoderMethods
-    end
-  end
-
-  let(:command_class) { TestEncoderMethods::TestCommand }
-  subject { command_class.new }
-
-  describe "#encoder_type" do
-    context "when given a HTMLEncoder class" do
-      module TestEncoderMethods
-        class TestHTMLEncoder < Ronin::Payloads::Encoders::HTMLEncoder
-        end
-      end
-
-      let(:klass) { TestEncoderMethods::TestHTMLEncoder }
-
-      it "must return 'html'" do
-        expect(subject.encoder_type(klass)).to eq('html')
-      end
-    end
-
-    context "when given a JavaScriptEncoder class" do
-      module TestEncoderMethods
-        class TestJavaScriptEncoder < Ronin::Payloads::Encoders::JavaScriptEncoder
-        end
-      end
-
-      let(:klass) { TestEncoderMethods::TestJavaScriptEncoder }
-
-      it "must return 'javascript'" do
-        expect(subject.encoder_type(klass)).to eq('javascript')
-      end
-    end
-
-    context "when given a ShellEncoder class" do
-      module TestEncoderMethods
-        class TestShellEncoder < Ronin::Payloads::Encoders::ShellEncoder
-        end
-      end
-
-      let(:klass) { TestEncoderMethods::TestShellEncoder }
-
-      it "must return 'shell'" do
-        expect(subject.encoder_type(klass)).to eq('shell')
-      end
-    end
-
-    context "when given a PowerShellEncoder class" do
-      module TestEncoderMethods
-        class TestPowerShellEncoder < Ronin::Payloads::Encoders::PowerShellEncoder
-        end
-      end
-
-      let(:klass) { TestEncoderMethods::TestPowerShellEncoder }
-
-      it "must return 'powershell'" do
-        expect(subject.encoder_type(klass)).to eq('powershell')
-      end
-    end
-
-    context "when given a SQLgEncoder class" do
-      module TestEncoderMethods
-        class TestSQLgEncoder < Ronin::Payloads::Encoders::SQLEncoder
-        end
-      end
-
-      let(:klass) { TestEncoderMethods::TestSQLgEncoder }
-
-      it "must return 'sql'" do
-        expect(subject.encoder_type(klass)).to eq('sql')
-      end
-    end
-  end
-
-  describe "#load_encoder" do
-    let(:encoder_id) { 'html/encode' }
-
-    it "must call Encoders.load_class with the given ID" do
-      expect(Ronin::Payloads::Encoders).to receive(:load_class).with(encoder_id)
-      expect(subject).to_not receive(:exit)
-
-      subject.load_encoder(encoder_id)
-    end
-
-    context "when Ronin::Payloads::Encoders::ClassNotfound is raised" do
-      let(:message) { "class not found" }
-      let(:exception) do
-        Ronin::Payloads::Encoders::ClassNotFound.new(message)
-      end
-
-      it "must print an error message and exit with an error code" do
-        expect(Ronin::Payloads::Encoders).to receive(:load_class).with(encoder_id).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.load_encoder(encoder_id)
-        }.to output("#{subject.command_name}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when another type of exception is raised" do
-      let(:message)   { "unexpected error" }
-      let(:exception) { RuntimeError.new(message) }
-
-      it "must print the exception, an error message, and exit with -1" do
-        expect(Ronin::Payloads::Encoders).to receive(:load_class).with(encoder_id).and_raise(exception)
-        expect(subject).to receive(:print_exception).with(exception)
-        expect(subject).to receive(:exit).with(-1)
-
-        expect {
-          subject.load_encoder(encoder_id)
-        }.to output("#{subject.command_name}: an unhandled exception occurred while loading encoder #{encoder_id}#{$/}").to_stderr
-      end
-    end
-  end
-
-  describe "#load_encoder_from" do
-    let(:file) { '/path/to/html/encode.rb' }
-
-    it "must call Payloads.load_class with the given ID and file" do
-      expect(Ronin::Payloads::Encoders).to receive(:load_class_from_file).with(file)
-      expect(subject).to_not receive(:exit)
-
-      subject.load_encoder_from(file)
-    end
-
-    context "when Ronin::Payloads::ClassNotfound is raised" do
-      let(:message) { "class not found" }
-      let(:exception) do
-        Ronin::Payloads::ClassNotFound.new(message)
-      end
-
-      it "must print an error message and exit with an error code" do
-        expect(Ronin::Payloads::Encoders).to receive(:load_class_from_file).with(file).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.load_encoder_from(file)
-        }.to output("#{subject.command_name}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when another type of exception is raised" do
-      let(:message)   { "unexpected error" }
-      let(:exception) { RuntimeError.new(message) }
-
-      it "must print the exception, an error message, and exit with -1" do
-        expect(Ronin::Payloads::Encoders).to receive(:load_class_from_file).with(file).and_raise(exception)
-        expect(subject).to receive(:print_exception).with(exception)
-        expect(subject).to receive(:exit).with(-1)
-
-        expect {
-          subject.load_encoder_from(file)
-        }.to output(
-          "#{subject.command_name}: an unhandled exception occurred while loading encoder from file #{file}#{$/}"
-        ).to_stderr
-      end
-    end
-  end
-
-  describe "#initialie_encoder" do
-    let(:encoder_id)    { 'test' }
-    let(:encoder_class) { double('Encoder class', id: encoder_id) }
-
-    it "must return a new instance of the given encoder class" do
-      expect(encoder_class).to receive(:new)
-
-      subject.initialize_encoder(encoder_class)
-    end
-
-    context "when additional keyword arguments are given" do
-      let(:kwargs) do
-        {foo: 1, bar: 2}
-      end
-
-      it "must pass them to new()" do
-        expect(encoder_class).to receive(:new).with(**kwargs)
-
-        subject.initialize_encoder(encoder_class,**kwargs)
-      end
-    end
-
-    context "when a Core::Params::ParamError is raised" do
-      let(:message)   { "param foo was not set" }
-      let(:exception) { Ronin::Core::Params::RequiredParam.new(message) }
-
-      it "must print an error message and exit with 1" do
-        expect(encoder_class).to receive(:new).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.initialize_encoder(encoder_class)
-        }.to output("#{subject.command_name}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when another type of exception is raised" do
-      let(:message)   { "unexpected error" }
-      let(:exception) { RuntimeError.new(message) }
-
-      it "must print the exception, an error message, and exit with -1" do
-        expect(encoder_class).to receive(:new).and_raise(exception)
-        expect(subject).to receive(:print_exception).with(exception)
-        expect(subject).to receive(:exit).with(-1)
-
-        expect {
-          subject.initialize_encoder(encoder_class)
-        }.to output("#{subject.command_name}: an unhandled exception occurred while initializing encoder #{encoder_id}#{$/}").to_stderr
-      end
-    end
-  end
-
-  describe "#validate_encoder" do
-    let(:encoder_id) { 'test' }
-    let(:encoder)    { double('Encoder instance', class_id: encoder_id) }
-
-    it "must return a new instance of the given encoder class" do
-      expect(encoder).to receive(:validate)
-
-      subject.validate_encoder(encoder)
-    end
-
-    context "when a Core::Params::ParamError is raised" do
-      let(:message)   { "param foo was not set" }
-      let(:exception) { Ronin::Core::Params::RequiredParam.new(message) }
-
-      it "must print an error message and exit with 1" do
-        expect(encoder).to receive(:validate).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.validate_encoder(encoder)
-        }.to output("#{subject.command_name}: failed to validate the encoder #{encoder_id}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when a Ronin::Payloads::Encoders::ValidationError is raised" do
-      let(:message)   { "param foo was not set" }
-      let(:exception) do
-        Ronin::Payloads::Encoders::ValidationError.new(message)
-      end
-
-      it "must print an error message and exit with 1" do
-        expect(encoder).to receive(:validate).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.validate_encoder(encoder)
-        }.to output("#{subject.command_name}: failed to validate the encoder #{encoder_id}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when another type of exception is raised" do
-      let(:message)   { "unexpected error" }
-      let(:exception) { RuntimeError.new(message) }
-
-      it "must print the exception, an error message, and exit with -1" do
-        expect(encoder).to receive(:validate).and_raise(exception)
-        expect(subject).to receive(:print_exception).with(exception)
-        expect(subject).to receive(:exit).with(-1)
-
-        expect {
-          subject.validate_encoder(encoder)
-        }.to output("#{subject.command_name}: an unhandled exception occurred while validating the encoder #{encoder_id}#{$/}").to_stderr
-      end
-    end
-  end
-end

data/spec/cli/format_option_spec.rb

@@ -1,187 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/cli/format_option'
-require 'ronin/payloads/cli/command'
-
-require 'stringio'
-
-describe Ronin::Payloads::CLI::FormatOption do
-  module TestFormatOption
-    class TestCommand < Ronin::Payloads::CLI::Command
-      include Ronin::Payloads::CLI::FormatOption
-    end
-  end
-
-  let(:command_class) { TestFormatOption::TestCommand }
-  subject { command_class.new }
-
-  describe ".included" do
-    subject { command_class }
-
-    it "must add a -F,--format c|shell|js|ruby option" do
-      expect(subject.options[:format]).to_not be(nil)
-      expect(subject.options[:format].short).to eq('-F')
-      expect(subject.options[:format].value).to_not be(nil)
-      expect(subject.options[:format].value.type).to eq(
-        [:hex, :c, :shell, :powershell, :xml, :html, :js, :ruby]
-      )
-      expect(subject.options[:format].desc).to eq('Formats the outputed data')
-    end
-  end
-
-  describe "parse_options" do
-    context "when given '--format hex'" do
-      before { subject.parse_options(%w[--format hex]) }
-
-      it "must set #format to Ronin::Support::Encoding::Hex.escape" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::Hex.method(:escape)
-        )
-      end
-    end
-
-    context "when given '--format c'" do
-      before { subject.parse_options(%w[--format c]) }
-
-      it "must set #format to Ronin::Support::Encoding::C.quote" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::C.method(:quote)
-        )
-      end
-    end
-
-    context "when given '--format shell'" do
-      before { subject.parse_options(%w[--format shell]) }
-
-      it "must set #format to Ronin::Support::Encoding::Shell.quote" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::Shell.method(:quote)
-        )
-      end
-    end
-
-    context "when given '--format powershell'" do
-      before { subject.parse_options(%w[--format powershell]) }
-
-      it "must set #format to Ronin::Support::Encoding::PowerShell.quote" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::PowerShell.method(:quote)
-        )
-      end
-    end
-
-    context "when given '--format xml'" do
-      before { subject.parse_options(%w[--format xml]) }
-
-      it "must set #format to Ronin::Support::Encoding::XML.escape" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::XML.method(:escape)
-        )
-      end
-    end
-
-    context "when given '--format html'" do
-      before { subject.parse_options(%w[--format html]) }
-
-      it "must set #format to Ronin::Support::Encoding::HTML.escape" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::HTML.method(:escape)
-        )
-      end
-    end
-
-    context "when given '--format js'" do
-      before { subject.parse_options(%w[--format js]) }
-
-      it "must set #format to Ronin::Support::Encoding::JS.quote" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::JS.method(:quote)
-        )
-      end
-    end
-
-    context "when given '--format ruby'" do
-      before { subject.parse_options(%w[--format ruby]) }
-
-      it "must set #format to Ronin::Support::Encoding::Ruby.quote" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::Ruby.method(:quote)
-        )
-      end
-    end
-  end
-
-  describe "#format_data" do
-    let(:data) { "hello world" }
-
-    context "when #format is set" do
-      before { subject.parse_options(%w[--format html]) }
-
-      it "must call #encode on the #format" do
-        expect(subject.format_data(data)).to eq(
-          Ronin::Support::Encoding::HTML.escape(data)
-        )
-      end
-    end
-
-    context "when #format is not set" do
-      it "must return the data" do
-        expect(subject.format_data(data)).to eq(data)
-      end
-    end
-  end
-
-  describe "#print_data" do
-    let(:data) { "hello world" }
-
-    let(:stdout) { StringIO.new }
-    subject { command_class.new(stdout: stdout) }
-
-    context "when stdout is a TTY" do
-      before { expect(stdout).to receive(:tty?).and_return(true) }
-
-      context "when #format is set" do
-        before { subject.parse_options(%w[--format html]) }
-
-        it "must print the formatted data" do
-          subject.print_data(data)
-
-          expect(stdout.string).to eq(
-            "#{Ronin::Support::Encoding::HTML.escape(data)}#{$/}"
-          )
-        end
-      end
-
-      context "when #format is not set" do
-        it "must print the unformatted data" do
-          subject.print_data(data)
-
-          expect(stdout.string).to eq("#{data}#{$/}")
-        end
-      end
-    end
-
-    context "when stdout not is a TTY" do
-      before { expect(stdout).to receive(:tty?).and_return(false) }
-
-      context "when #format is set" do
-        before { subject.parse_options(%w[--format html]) }
-
-        it "must print the formatted data without a newline" do
-          subject.print_data(data)
-
-          expect(stdout.string).to eq(
-            "#{Ronin::Support::Encoding::HTML.escape(data)}"
-          )
-        end
-      end
-
-      context "when #format is not set" do
-        it "must print the unformatted data without a newline" do
-          subject.print_data(data)
-
-          expect(stdout.string).to eq(data)
-        end
-      end
-    end
-  end
-end

data/spec/cli/payload_command_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/cli/payload_command'
-require 'ronin/payloads/payload'
-
-describe Ronin::Payloads::CLI::PayloadCommand do
-  module TestPayloadCommand
-    class TestPayload < Ronin::Payloads::Payload
-      register 'test_payload_command'
-    end
-
-    class TestCommand < Ronin::Payloads::CLI::PayloadCommand
-    end
-  end
-
-  let(:payload_class) { TestPayloadCommand::TestPayload }
-  let(:command_class) { TestPayloadCommand::TestCommand }
-  subject { command_class.new }
-
-  describe "#load_payload" do
-    let(:id) { payload_class.id }
-
-    before do
-      expect(Ronin::Payloads).to receive(:load_class).with(id).and_return(payload_class)
-    end
-
-    it "must load the payload class and return the payload class" do
-      expect(subject.load_payload(id)).to be(payload_class)
-    end
-
-    it "must also set #payload_class" do
-      subject.load_payload(id)
-
-      expect(subject.payload_class).to be(payload_class)
-    end
-  end
-
-  describe "#load_payload_from" do
-    let(:file) { "path/to/payload/file.rb" }
-
-    before do
-      expect(Ronin::Payloads).to receive(:load_class_from_file).with(file).and_return(payload_class)
-    end
-
-    it "must load the payload class and return the payload class" do
-      expect(subject.load_payload_from(file)).to be(payload_class)
-    end
-
-    it "must also set #payload_class" do
-      subject.load_payload_from(file)
-
-      expect(subject.payload_class).to be(payload_class)
-    end
- end
-
-  describe "#initialize_payload" do
-    before { subject.load_payload(payload_class.id) }
-
-    it "must initialize a new payload object using #payload_class" do
-      expect(subject.initialize_payload).to be_kind_of(payload_class)
-    end
-
-    it "must also set #payload" do
-      subject.initialize_payload
-
-      expect(subject.payload).to be_kind_of(payload_class)
-    end
-  end
-end