ronin-core 0.1.0.beta1 → 0.1.0

data/spec/cli/options/param_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/cli/options/param'
-require 'ronin/core/cli/command'
-
-describe Ronin::Core::CLI::Options::Param do
-  module TestParamOption
-    class TestCommand < Ronin::Core::CLI::Command
-      include Ronin::Core::CLI::Options::Param
-    end
-  end
-
-  let(:command_class) { TestParamOption::TestCommand }
-
-  describe ".included" do
-    subject { command_class }
-
-    it "must add a -p,--param option to the options" do
-      expect(subject.options[:param]).to_not be_nil
-      expect(subject.options[:param].value?).to be(true)
-      expect(subject.options[:param].value.type).to be_kind_of(Regexp)
-      expect(subject.options[:param].value.usage).to eq('NAME=VALUE')
-      expect(subject.options[:param].desc).to eq('Sets a param')
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#initialize" do
-    it "must set #params to an empty Hash" do
-      expect(subject.params).to eq({})
-    end
-  end
-
-  describe "options" do
-    context "when given --param foo=bar" do
-      before { subject.option_parser.parse(%w[--param foo=bar]) }
-
-      it "must set the :foo key to 'bar' in #params" do
-        expect(subject.params[:foo]).to eq('bar')
-      end
-    end
-
-    context "when given --param foo=" do
-      it do
-        expect {
-          subject.option_parser.parse(%w[--param foo=])
-        }.to raise_error(OptionParser::InvalidArgument)
-      end
-    end
-
-    context "when given --param =bar" do
-      it do
-        expect {
-          subject.option_parser.parse(%w[--param =bar])
-        }.to raise_error(OptionParser::InvalidArgument)
-      end
-    end
-
-    context "when given --param =" do
-      it do
-        expect {
-          subject.option_parser.parse(%w[--param =])
-        }.to raise_error(OptionParser::InvalidArgument)
-      end
-    end
-  end
-end

data/spec/cli/options/values/arches_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/cli/options/values/arches'
-
-describe "Ronin::Core::CLI::Options::Values::ARCHES" do
-  subject { Ronin::Core::CLI::Options::Values::ARCHES }
-
-  it "must map 'x86' to :x86" do
-    expect(subject['x86']).to eq(:x86)
-  end
-
-  it "must map 'x86-64' to :x86_64" do
-    expect(subject['x86-64']).to eq(:x86_64)
-  end
-
-  it "must map 'amd64' to :x86_64" do
-    expect(subject['amd64']).to eq(:x86_64)
-  end
-
-  it "must map 'ia64' to :ia64" do
-    expect(subject['ia64']).to eq(:ia64)
-  end
-
-  it "must map 'ppc' to :ppc" do
-    expect(subject['ppc']).to eq(:ppc)
-  end
-
-  it "must map 'ppc64' to :ppc64" do
-    expect(subject['ppc64']).to eq(:ppc64)
-  end
-
-  it "must map 'arm' to :arm" do
-    expect(subject['arm']).to eq(:arm)
-  end
-
-  it "must map 'armbe' to :arm_be" do
-    expect(subject['armbe']).to eq(:arm_be)
-  end
-
-  it "must map 'arm64' to :arm64" do
-    expect(subject['arm64']).to eq(:arm64)
-  end
-
-  it "must map 'arm64be' to :arm64_be" do
-    expect(subject['arm64be']).to eq(:arm64_be)
-  end
-
-  it "must map 'mips' to :mips" do
-    expect(subject['mips']).to eq(:mips)
-  end
-
-  it "must map 'mipsle' to :mips_le" do
-    expect(subject['mipsle']).to eq(:mips_le)
-  end
-
-  it "must map 'mips64' to :mips64" do
-    expect(subject['mips64']).to eq(:mips64)
-  end
-
-  it "must map 'mips64le' to :mips64_le" do
-    expect(subject['mips64le']).to eq(:mips64_le)
-  end
-end

data/spec/cli/printing/arch_spec.rb

@@ -1,130 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/cli/printing/arch'
-require 'ronin/core/cli/command'
-
-describe Ronin::Core::CLI::Printing::Arch do
-  module TestPrintingArch
-    class TestCommand < Ronin::Core::CLI::Command
-      include Ronin::Core::CLI::Printing::Arch
-    end
-  end
-
-  let(:command_class) { TestPrintingArch::TestCommand }
-  subject { command_class.new }
-
-  describe "#arch_name" do
-    context "when given :x86" do
-      it "must return 'x86'" do
-        expect(subject.arch_name(:x86)).to eq('x86')
-      end
-    end
-
-    context "when given :x86_64" do
-      it "must return 'x86-64'" do
-        expect(subject.arch_name(:x86_64)).to eq('x86-64')
-      end
-    end
-
-    context "when given :ia64" do
-      it "must return 'ia64'" do
-        expect(subject.arch_name(:ia64)).to eq('IA64')
-      end
-    end
-
-    context "when given :amd64" do
-      it "must return 'x86-64'" do
-        expect(subject.arch_name(:amd64)).to eq('x86-64')
-      end
-    end
-
-    context "when given :ppc" do
-      it "must return 'PPC'" do
-        expect(subject.arch_name(:ppc)).to eq('PPC')
-      end
-    end
-
-    context "when given :ppc64" do
-      it "must return 'PPC64'" do
-        expect(subject.arch_name(:ppc64)).to eq('PPC64')
-      end
-    end
-
-    context "when given :mips" do
-      it "must return 'MIPS'" do
-        expect(subject.arch_name(:mips)).to eq('MIPS')
-      end
-    end
-
-    context "when given :mips_le" do
-      it "must return 'MIPS (LE)'" do
-        expect(subject.arch_name(:mips_le)).to eq('MIPS (LE)')
-      end
-    end
-
-    context "when given :mips_be" do
-      it "must return 'MIPS'" do
-        expect(subject.arch_name(:mips_be)).to eq('MIPS')
-      end
-    end
-
-    context "when given :mips64" do
-      it "must return 'MIPS64'" do
-        expect(subject.arch_name(:mips64)).to eq('MIPS64')
-      end
-    end
-
-    context "when given :mips64_le" do
-      it "must return 'MIPS64 (LE)'" do
-        expect(subject.arch_name(:mips64_le)).to eq('MIPS64 (LE)')
-      end
-    end
-
-    context "when given :mips64_be" do
-      it "must return 'MIPS64'" do
-        expect(subject.arch_name(:mips64_be)).to eq('MIPS64')
-      end
-    end
-
-    context "when given :arm" do
-      it "must return 'ARM'" do
-        expect(subject.arch_name(:arm)).to eq('ARM')
-      end
-    end
-
-    context "when given :arm_le" do
-      it "must return 'ARM'" do
-        expect(subject.arch_name(:arm_le)).to eq('ARM')
-      end
-    end
-
-    context "when given :arm_be" do
-      it "must return 'ARM (BE)'" do
-        expect(subject.arch_name(:arm_be)).to eq('ARM (BE)')
-      end
-    end
-
-    context "when given :arm64" do
-      it "must return 'ARM64'" do
-        expect(subject.arch_name(:arm64)).to eq('ARM64')
-      end
-    end
-
-    context "when given :arm64_le" do
-      it "must return 'ARM64'" do
-        expect(subject.arch_name(:arm64_le)).to eq('ARM64')
-      end
-    end
-
-    context "when given :arm64_be" do
-      it "must return 'ARM64 (BE)'" do
-        expect(subject.arch_name(:arm64_be)).to eq('ARM64 (BE)')
-      end
-    end
-
-    context "when given an unknown architecture" do
-      it "must return the String version of the architecture" do
-        expect(subject.arch_name(:foo)).to eq('foo')
-      end
-    end
-  end
-end

data/spec/cli/printing/metadata_spec.rb

@@ -1,211 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/cli/printing/metadata'
-require 'ronin/core/cli/command'
-require 'ronin/core/metadata/authors'
-require 'ronin/core/metadata/description'
-require 'ronin/core/metadata/references'
-
-describe Ronin::Core::CLI::Printing::Metadata do
-  module TestPrintingMetadata
-    class TestCommand < Ronin::Core::CLI::Command
-      include Ronin::Core::CLI::Printing::Metadata
-    end
-  end
-
-  let(:command_class) { TestPrintingMetadata::TestCommand }
-  subject { command_class.new }
-
-  describe ".included" do
-    subject { command_class }
-
-    it "must add a -v,--verbose option" do
-      expect(subject.options[:verbose]).to_not be_nil
-    end
-  end
-
-  describe "#print_authors" do
-    module TestPrintingAuthors
-      class WithoutAuthors
-        include Ronin::Core::Metadata::Authors
-      end
-
-      class WithAuthors
-        include Ronin::Core::Metadata::Authors
-
-        author 'John Doe', email:   'john.doe@example.com',
-                           pgp:     '0x123456789',
-                           website: 'https://johndoe.name',
-                           blog:    'https://johndoe.name/blog',
-                           github:  '@johndoe',
-                           gitlab:  '@johndoe',
-                           twitter: '@johndoe',
-                           discord: 'https://discord.gg/1234'
-
-        author 'John Smith', email:   'john.smith@example.com',
-                             pgp:     '0xABCDEF',
-                             website: 'https://johnsmith.name',
-                             blog:    'https://johnsmith.name/blog',
-                             github:  '@john.smith',
-                             gitlab:  '@john.smith',
-                             twitter: '@john.smith',
-                             discord: 'https://discord.gg/ABCDEF'
-      end
-    end
-
-    context "when the class does not have any authors" do
-      let(:klass) { TestPrintingAuthors::WithoutAuthors }
-
-      it "must not print anything" do
-        expect {
-          subject.print_authors(klass)
-        }.to_not output.to_stdout
-      end
-    end
-
-    context "when the class does have authors" do
-      let(:klass) { TestPrintingAuthors::WithAuthors }
-
-      it "must print 'Authors:' and a list of authors" do
-        expect {
-          subject.print_authors(klass)
-        }.to output(
-          [
-            'Authors:',
-            '',
-            "  * #{klass.authors[0]}",
-            "  * #{klass.authors[1]}",
-            '',
-            ''
-          ].join($/)
-        ).to_stdout
-      end
-
-      context "when --verbose mode is enabled" do
-        before { allow(subject).to receive(:verbose?).and_return(true) }
-
-        it "must print the authors and any author metadata as indented lists" do
-          expect {
-            subject.print_authors(klass)
-          }.to output(
-            [
-              'Authors:',
-              '',
-              "  * #{klass.authors[0]}",
-              "    * PGP: #{klass.authors[0].pgp}",
-              "    * Website: #{klass.authors[0].website}",
-              "    * Blog: #{klass.authors[0].blog}",
-              "    * GitHub: #{klass.authors[0].github_url}",
-              "    * GitLab: #{klass.authors[0].gitlab_url}",
-              "    * Twitter: #{klass.authors[0].twitter_url}",
-              "    * Discord: #{klass.authors[0].discord}",
-              "  * #{klass.authors[1]}",
-              "    * PGP: #{klass.authors[1].pgp}",
-              "    * Website: #{klass.authors[1].website}",
-              "    * Blog: #{klass.authors[1].blog}",
-              "    * GitHub: #{klass.authors[1].github_url}",
-              "    * GitLab: #{klass.authors[1].gitlab_url}",
-              "    * Twitter: #{klass.authors[1].twitter_url}",
-              "    * Discord: #{klass.authors[1].discord}",
-              '',
-              ''
-            ].join($/)
-          ).to_stdout
-        end
-      end
-    end
-  end
-
-  describe "#print_description" do
-    module TestPrintingDescription
-      class WithoutDescription
-        include Ronin::Core::Metadata::Description
-      end
-
-      class WithDescription
-        include Ronin::Core::Metadata::Description
-
-        description <<~DESC
-          Foo bar baz
-
-          Qux quux gorge
-        DESC
-      end
-    end
-
-    context "when the class does not have a description" do
-      let(:klass) { TestPrintingDescription::WithoutDescription }
-
-      it "must not print anything" do
-        expect {
-          subject.print_description(klass)
-        }.to_not output.to_stdout
-      end
-    end
-
-    context "when the class does have a description" do
-      let(:klass) { TestPrintingDescription::WithDescription }
-
-      it "must print 'Description:' and the indented description text" do
-        expect {
-          subject.print_description(klass)
-        }.to output(
-          [
-            'Description:',
-            '',
-            "  #{klass.description.lines[0].chomp}",
-            "  #{klass.description.lines[1].chomp}",
-            "  #{klass.description.lines[2].chomp}",
-            '',
-            ''
-          ].join($/)
-        ).to_stdout
-      end
-    end
-  end
-
-  describe "#print_references" do
-    module TestPrintingReferences
-      class WithoutReferences
-        include Ronin::Core::Metadata::References
-      end
-
-      class WithReferences
-        include Ronin::Core::Metadata::References
-
-        references [
-          'https://example.com/url1',
-          'https://example.com/url2'
-        ]
-      end
-    end
-
-    context "when the class has no references" do
-      let(:klass) { TestPrintingReferences::WithoutReferences }
-
-      it "must not print anything" do
-        expect {
-          subject.print_references(klass)
-        }.to_not output.to_stdout
-      end
-    end
-
-    context "when the class has references" do
-      let(:klass) { TestPrintingReferences::WithReferences }
-
-      it "must print 'References:' and the list of reference URLs" do
-        expect {
-          subject.print_references(klass)
-        }.to output(
-          [
-            'References:',
-            '',
-            "  * #{klass.references[0]}",
-            "  * #{klass.references[1]}",
-            '',
-            ''
-          ].join($/)
-        ).to_stdout
-      end
-    end
-  end
-end

data/spec/cli/printing/os_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/cli/printing/os'
-require 'ronin/core/cli/command'
-
-describe Ronin::Core::CLI::Printing::OS do
-  module TestPrintingOS
-    class TestCommand < Ronin::Core::CLI::Command
-      include Ronin::Core::CLI::Printing::OS
-    end
-  end
-
-  let(:command_class) { TestPrintingOS::TestCommand }
-  subject { command_class.new }
-
-  describe "#os_name" do
-    context "when given :unix" do
-      it "must return 'UNIX'" do
-        expect(subject.os_name(:unix)).to eq('UNIX')
-      end
-    end
-
-    context "when given :bsd" do
-      it "must return 'BSD'" do
-        expect(subject.os_name(:bsd)).to eq('BSD')
-      end
-    end
-
-    context "when given :freebsd" do
-      it "must return 'FreeBSD'" do
-        expect(subject.os_name(:freebsd)).to eq('FreeBSD')
-      end
-    end
-
-    context "when given :openbsd" do
-      it "must return 'OpenBSD'" do
-        expect(subject.os_name(:openbsd)).to eq('OpenBSD')
-      end
-    end
-
-    context "when given :netbsd" do
-      it "must return 'NetBSD'" do
-        expect(subject.os_name(:netbsd)).to eq('NetBSD')
-      end
-    end
-
-    context "when given :linux" do
-      it "must return 'Linux'" do
-        expect(subject.os_name(:linux)).to eq('Linux')
-      end
-    end
-
-    context "when given :macos" do
-      it "must return 'macOS'" do
-        expect(subject.os_name(:macos)).to eq('macOS')
-      end
-    end
-
-    context "when given :windows" do
-      it "must return 'Windows'" do
-        expect(subject.os_name(:windows)).to eq('Windows')
-      end
-    end
-  end
-end

data/spec/cli/printing/params_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/cli/printing/params'
-require 'ronin/core/cli/command'
-require 'ronin/core/params/mixin'
-
-describe Ronin::Core::CLI::Printing::Params do
-  module TestPrintingParams
-    class TestClass
-
-      include Ronin::Core::Params::Mixin
-
-      param :foo, String, required: true,
-                          desc: 'Foo param'
-      param :bar, Integer, default: 42,
-                           desc: 'Bar param'
-
-    end
-
-    class TestClassWithoutParams
-      include Ronin::Core::Params::Mixin
-    end
-
-    class TestCommand < Ronin::Core::CLI::Command
-      include Ronin::Core::CLI::Printing::Params
-    end
-  end
-
-  let(:test_class)   { TestPrintingParams::TestClass   }
-  let(:test_command) { TestPrintingParams::TestCommand }
-  subject { test_command.new }
-
-  describe "#print_params" do
-    context "when the class has defined params" do
-      it "must print Params: and the params table" do
-        expect {
-          subject.print_params(test_class)
-        }.to output(
-          [
-            "Params:",
-            "",
-            "  ┌──────┬─────────┬──────────┬─────────┬─────────────┐",
-            "  │ Name │  Type   │ Required │ Default │ Description │",
-            "  ├──────┼─────────┼──────────┼─────────┼─────────────┤",
-            "  │ foo  │ String  │ Yes      │         │ Foo param   │",
-            "  │ bar  │ Integer │ No       │ 42      │ Bar param   │",
-            "  └──────┴─────────┴──────────┴─────────┴─────────────┘",
-            ""
-          ].join($/)
-        ).to_stdout
-      end
-    end
-
-    context "when the class does not have any defined params" do
-      let(:test_class) { TestPrintingParams::TestClassWithoutParams }
-
-      it "must not print anything" do
-        expect {
-          subject.print_params(test_class)
-        }.to_not output.to_stdout
-      end
-    end
-  end
-end

data/spec/cli/ruby_shell.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/cli/ruby_shell'
-
-describe Ronin::Core::CLI::RubyShell do
-  describe "#initialize" do
-    it "must default #name to 'ronin'" do
-      expect(subject.name).to eq('ronin')
-    end
-
-    context "when given a name: keyword argument" do
-      let(:name) { 'ronin-foo' }
-
-      subject { described_class.new(name: name) }
-
-      it "must set #name" do
-        expect(subject.name).to eq(name)
-      end
-    end
-
-    it "must default #context to nil" do
-      expect(subject.context).to be(nil)
-    end
-
-    context "when given a context: keyword argument" do
-      let(:context) { Object.new }
-
-      subject { described_class.new(context: context) }
-
-      it "must set #context" do
-        expect(subject.context).to be(context)
-      end
-    end
-  end
-
-  describe "#configure" do
-    before { subject.configure }
-
-    it "must call IRB.setup" do
-      expect(IRB.conf.length).to be > 1
-    end
-
-    it "must set IRB.conf[:IRB_NAME] to #name" do
-      expect(IRB.conf[:IRB_NAME]).to eq(subject.name)
-    end
-
-    let(:colors)          { subject.colors(STDOUT) }
-    let(:red)             { colors::RED }
-    let(:bright_red)      { colors::BRIGHT_RED }
-    let(:bold)            { colors::BOLD }
-    let(:reset_intensity) { colors::RESET_INTENSITY }
-    let(:reset_color)     { colors::RESET_COLOR     }
-
-    it "must set IRB.conf[:PROMPT][:RONIN]" do
-      expect(IRB.conf[:PROMPT][:RONIN]).to eq(
-        {
-          AUTO_INDENT: true,
-          PROMPT_I: "#{red}irb#{reset_color}#{bold}#{bright_red}(#{reset_color}#{reset_intensity}#{red}%N#{reset_color}#{bold}#{bright_red})#{reset_color}#{reset_intensity}#{bold}#{bright_red}>#{reset_color}#{reset_intensity} ",
-          PROMPT_S: "#{red}irb#{reset_color}#{bold}#{bright_red}(#{reset_color}#{reset_intensity}#{red}%N#{reset_color}#{bold}#{bright_red})#{reset_color}#{reset_intensity}%l ",
-          PROMPT_C: "#{red}irb#{reset_color}#{bold}#{bright_red}(#{reset_color}#{reset_intensity}#{red}%N#{reset_color}#{bold}#{bright_red})#{reset_color}#{reset_intensity}* ",
-          RETURN: "=> %s#{$/}"
-        }
-      )
-    end
-
-    it "must set IRB.conf[:PROMPT_MODE] to :RONIN" do
-      expect(IRB.conf[:PROMPT_MODE]).to eq(:RONIN)
-    end
-
-    after do
-      IRB.conf[:IRB_NAME] = nil
-      IRB.conf[:PROMPT].delete(:RONIN)
-      IRB.conf[:PROMPT_MODE] = :DEFAULT
-    end
-  end
-
-  describe "#start" do
-    let(:fixtures_dir) { File.expand_path(File.join(__dir__,'fixtures')) }
-    let(:console_bin)  { File.join(fixtures_dir,'irb_command') }
-
-    it "must print a prompt then read and evaluate Ruby" do
-      output = nil
-
-      IO.popen(console_bin,'r+') do |io|
-        io.puts "1 + 1"
-        io.puts "exit"
-
-        output = io.read
-      end
-
-      expect(output).to eq([
-        "Switch to inspect mode.",
-        "irb(ronin)> 1 + 1",
-        "=> 2",
-        "irb(ronin)> exit",
-        ''
-      ].join($/))
-    end
-  end
-end