ronin 2.0.0.beta1 → 2.0.0.beta2

data/spec/cli/string_processor_command_spec.rb

@@ -1,258 +0,0 @@
-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

data/spec/cli/value_processor_command_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-require 'ronin/cli/value_processor_command'
-
-describe Ronin::CLI::ValueProcessorCommand do
-  module TestValueProcessorCommand
-    class TestCommand < Ronin::CLI::ValueProcessorCommand
-
-      def process_value(string)
-        puts string.reverse
-      end
-
-    end
-  end
-
-  let(:test_class) { TestValueProcessorCommand::TestCommand }
-  subject { test_class.new }
-
-  describe "#initialize" do
-    it "must initialize #files to an empty Array" do
-      expect(subject.files).to eq([])
-    end
-  end
-
-  describe "options" do
-    describe "--file" do
-      let(:file1) { 'file1.txt' }
-      let(:file2) { 'file2.txt' }
-      let(:argv) do
-        ['--file', file1, '--file', file2]
-      end
-      before { subject.parse_options(argv) }
-
-      it "must append the argument value to #files" do
-        expect(subject.files).to eq([file1, file2])
-      end
-    end
-  end
-
-  let(:fixtures_dir) { File.join(__dir__,'fixtures') }
-  let(:file)         { File.join(fixtures_dir,'file.txt') }
-
-  describe "#run" do
-    context "when arguments are given" do
-      let(:args) { %w[foo bar baz] }
-      let(:expected_output) do
-        args.map(&:reverse).join($/) + $/
-      end
-
-      it "must process each argument and print output to stdout" do
-        expect {
-          subject.run(*args)
-        }.to output(expected_output).to_stdout
-      end
-    end
-
-    context "when --file options are given" do
-      let(:argv) { ['--file', file] }
-      let(:expected_output) do
-        File.readlines(file, chomp: true).map(&:reverse).join($/) + $/
-      end
-
-      before { subject.parse_options(argv) }
-
-      it "must read and process each --file argument and print output to stdout" do
-        expect {
-          subject.run()
-        }.to output(expected_output).to_stdout
-      end
-    end
-
-    context "when --file options and arguments are given" do
-      let(:argv) { ['--file', file] }
-      let(:args) { %w[abc def ghi] }
-
-      let(:expected_values) { File.readlines(file, chomp: true) + args }
-      let(:expected_output) do
-        expected_values.map(&:reverse).join($/) + $/
-      end
-
-      before { subject.parse_options(argv) }
-
-      it "must read and process the --file arguments then the arguments" do
-        expect {
-          subject.run(*args)
-        }.to output(expected_output).to_stdout
-      end
-    end
-
-    context "when neither --file options nor arguments are given" do
-      it "must print an error message to stderr and exit with 1" do
-        expect(subject).to receive(:print_error).with(
-          "must specify one or more arguments, or the --file option"
-        )
-
-        expect {
-          subject.run()
-        }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
-        end
-      end
-    end
-  end
-
-  describe "#process_file" do
-    let(:expected_output) do
-      File.readlines(file, chomp: true).map(&:reverse).join($/) + $/
-    end
-
-    it "must read and process each line of the file and print them to stdout" do
-      expect {
-        subject.process_file(file)
-      }.to output(expected_output).to_stdout
-    end
-  end
-
-  describe "#process_value" do
-    subject { described_class.new }
-
-    let(:value) { "foo" }
-
-    it do
-      expect {
-        subject.process_value(value)
-      }.to raise_error(NotImplementedError,"#{subject.class}#process_value method was not implemented")
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,5 +0,0 @@
-require 'rspec'
-require 'simplecov'
-SimpleCov.start
-
-include Ronin

data/spec/version_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-require 'ronin/version'
-
-describe Ronin do
-  it "should have a version" do
-    version = subject.const_get('VERSION')
-
-    expect(version).not_to be_nil
-    expect(version).not_to be_empty
-  end
-end