ronin 1.5.1 → 2.0.0.beta1

data/spec/ui/cli/command_spec.rb

@@ -1,291 +0,0 @@
-require 'spec_helper'
-require 'ronin/ui/cli/command'
-
-require 'ui/cli/classes/test_command'
-
-describe UI::CLI::Command do
-  subject { TestCommand }
-
-  describe "command_name" do
-    it "should be derived from the Class name" do
-      expect(subject.command_name).to eq('test_command')
-    end
-  end
-
-  describe "usage" do
-    context "without an argument" do
-      it "should return the set usage" do
-        expect(subject.usage).to eq('[options] PATH FILE [..]')
-      end
-    end
-
-    context "with an argument" do
-      let(:expected) { 'FOO' }
-
-      subject { Class.new(described_class) }
-      before  { subject.usage expected }
-
-      it "should set the usage" do
-        expect(subject.usage).to eq(expected)
-      end
-    end
-
-    context "default" do
-      subject { Class.new(described_class).usage }
-
-      it { should == '[options]' }
-    end
-
-    context "inherited" do
-      let(:superclass) { TestCommand }
-
-      subject { Class.new(superclass).usage }
-
-      it "should default to the usage of the superclass" do
-        expect(subject).to eq(superclass.usage)
-      end
-    end
-  end
-
-  describe "summary" do
-    context "without an argument" do
-      it "should return the set summary" do
-        expect(subject.summary).to eq('Tests the default task')
-      end
-    end
-
-    context "with an argument" do
-      let(:expected) { 'Performs foo' }
-
-      subject { Class.new(described_class) }
-      before  { subject.summary expected }
-
-      it "should set the usage" do
-        expect(subject.summary).to eq(expected)
-      end
-    end
-
-    context "default" do
-      subject { Class.new(described_class).summary }
-
-      it { should == nil }
-    end
-
-    context "inherited" do
-      let(:superclass) { TestCommand }
-
-      subject { Class.new(superclass).summary }
-
-      it "should default to the summary of the superclass" do
-        expect(subject).to eq(superclass.summary)
-      end
-    end
-  end
-
-  describe "examples" do
-    context "without an argument" do
-      it "should return the set summary" do
-        # subject.example.should == 'Tests the default task'
-      end
-    end
-
-    context "with an argument" do
-      let(:expected) do
-        ['test_command --foo PATH', 'test_command --foo PATH FILE ...']
-      end
-
-      subject { Class.new(described_class) }
-      before  { subject.examples expected }
-
-      it "should set the usage" do
-        expect(subject.examples).to eq(expected)
-      end
-    end
-
-    context "default" do
-      subject { Class.new(described_class).examples }
-
-      it { should == [] }
-    end
-
-    context "inherited" do
-      let(:superclass) { TestCommand }
-
-      subject { Class.new(superclass).examples }
-
-      it "should default to the examples of the superclass" do
-        expect(subject).to eq(superclass.examples)
-      end
-    end
-  end
-
-  describe "options" do
-    subject { Class.new(described_class).options }
-
-    context "inherited" do
-      it "should be {} by default" do
-        expect(subject).to eq({})
-      end
-    end
-
-    context described_class do
-      subject { described_class.options }
-
-      it "should have a :verbose option" do
-        expect(subject).to have_key(:verbose)
-      end
-
-      it "should have a :quiet option" do
-        expect(subject).to have_key(:quiet)
-      end
-
-      it "should have a :silent option" do
-        expect(subject).to have_key(:silent)
-      end
-
-      it "should have a :color option" do
-        expect(subject).to have_key(:color)
-      end
-
-      describe "color option" do
-        subject { described_class.new.color }
-
-        context "when $stdout is a TTY" do
-          it do
-            skip "$stdout is not a TTY" unless $stdout.tty?
-
-            expect(subject).to be(true)
-          end
-        end
-
-        context "when $stdout is not a TTY" do
-          before do
-            @old_stdout = $stdout
-            $stdout     = StringIO.new
-          end
-
-          it { expect(subject).to be(false) }
-
-          after do
-            $stdout = @old_stdout
-          end
-        end
-      end
-    end
-  end
-
-  describe "option" do
-    let(:name) { :foo }
-
-    it "should define an option" do
-      expect(subject.options[name]).to be_kind_of(Hash)
-    end
-
-    it "should define a parameter" do
-      expect(subject).to have_param(name)
-    end
-  end
-
-  describe "each_option" do
-    let(:expected) { [:verbose, :quiet, :silent, :color, :foo] }
-
-    it "should iterate over each option" do
-      names = []
-
-      subject.each_option do |name,options|
-        names << name
-      end
-
-      expect(names).to match_array(expected)
-    end
-  end
-
-  describe "options?" do
-    it "should test if there are any defined options" do
-      expect(subject.options?).to be(true)
-    end
-  end
-
-  describe "arguments" do
-    context "inherited" do
-      subject { Class.new(described_class).arguments }
-
-      it { should == [] }
-    end
-  end
-
-  describe "argument" do
-    let(:name) { :foo }
-
-    subject { Class.new(described_class) }
-    before  { subject.argument name      }
-
-    it "should add to arguments" do
-      expect(subject.arguments).to include(name)
-    end
-
-    it "should define a parameter" do
-      expect(subject).to have_param(name)
-    end
-  end
-
-  describe "each_argument" do
-    let(:expected) { [:path, :files] }
-
-    it "should iterate over each option" do
-      names = []
-
-      subject.each_argument { |name| names << name }
-
-      expect(names).to match_array(expected)
-    end
-  end
-
-  describe "arguments?" do
-    it "should test if there are any defined arguments" do
-      expect(subject.arguments?).to be(true)
-    end
-  end
-
-  describe "#run" do
-    it "should allow running the command with options" do
-      command = subject.new
-      value   = 'bar'
-
-      command.run(:foo => value)
-
-      expect(command.foo).to eq(value)
-    end
-  end
-
-  describe "#start" do
-    subject { TestCommand.new }
-
-    it "should parse options" do
-      value = 'baz'
-      subject.start(['--foo', value])
-
-      expect(subject.foo).to eq(value)
-    end
-
-    it "should parse additional arguments" do
-      path = 'to/file.txt'
-
-      subject.start([path])
-
-      expect(subject.path).to eq(path)
-    end
-
-    it "should parse additional arguments into an Array/Set argument" do
-      value = 'bax'
-      path  = 'to/file.txt'
-      files = ['one.txt', 'two.txt']
-
-      subject.start(['--foo', value, path, *files])
-
-      expect(subject.foo).to eq(value)
-      expect(subject.path).to eq(path)
-      expect(subject.files).to eq(files)
-    end
-  end
-end

data/spec/url_query_param_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/url_query_param'
-
-describe URLQueryParam do
-  let(:name)  { 'foo' }
-  let(:value) { 'bar' }
-
-  subject do
-    described_class.new(:name => {:name => name}, :value => value)
-  end
-
-  describe "#to_s" do
-    it "should dump a name and a value into a String" do
-      expect(subject.to_s).to eq("#{name}=#{value}")
-    end
-
-    context "with empty or nil values" do
-      subject do
-        described_class.new(:name => {:name => name})
-      end
-
-      it "should ignore empty or nil values" do
-        expect(subject.to_s).to eq("#{name}=")
-      end
-    end
-
-    context "with special characters" do
-      let(:value)         { 'bar baz'         }
-      let(:encoded_value) { URI::DEFAULT_PARSER.escape(value) }
-
-      subject do
-        described_class.new(:name => {:name => name}, :value => value)
-      end
-
-      it "should escape special characters" do
-        expect(subject.to_s).to eq("#{name}=#{encoded_value}")
-      end
-    end
-  end
-end

data/spec/url_scheme_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/url_scheme'
-
-describe URLScheme do
-  before(:all) { described_class.create(:name => 'http') }
-
-  describe "validations" do
-    it "should require a name" do
-      expect(subject).not_to be_valid
-    end
-
-    describe "name" do
-      subject { described_class.new(:name => 'http') }
-
-      it "should require a unique name" do
-        expect(subject).not_to be_valid
-      end
-    end
-  end
-end

data/spec/url_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/url'
-
-describe URL do
-  let(:scheme) { 'https' }
-  let(:host_name) { 'www.example.com' }
-  let(:port) { 8080 }
-  let(:path) { '/path' }
-  let(:query_params) { {'q' => '1'} }
-  let(:query_string) { 'q=1' }
-  let(:fragment) { 'frag' }
-
-  let(:uri) do
-    URI::HTTPS.build(
-      :scheme   => scheme,
-      :host     => host_name,
-      :port     => port,
-      :path     => path,
-      :query    => query_string,
-      :fragment => fragment
-    )
-  end
-
-  let(:url) do
-    described_class.new(
-      :scheme    => URLScheme.first_or_create(:name => scheme),
-      :host_name => HostName.first_or_create(:address => host_name),
-      :port      => TCPPort.first_or_create(:number => port),
-      :path      => path,
-      :fragment  => fragment,
-      :query_params => [{
-        :name => URLQueryParamName.first_or_create(
-                   :name => query_params.keys[0]
-                 ),
-        :value => query_params.values[0]
-      }]
-    )
-  end
-
-  describe "extract" do
-    subject { described_class }
-
-    let(:url1) { subject.parse("http://example.com/page.php?x=1&y=2") }
-    let(:url2) { subject.parse("ssh://alice@example.com") }
-    let(:text) { "foo #{url1}, bar #{url2} baz" }
-
-    it "should extract multiple URLs from text" do
-      expect(subject.extract(text)).to be == [url1, url2]
-    end
-
-    it "should yield the extracted URLs if a block is given" do
-      urls = []
-
-      subject.extract(text) { |url| urls << url }
-
-      expect(urls).to be == [url1, url2]
-    end
-
-    it "should ignore non-absolute URIs" do
-      expect(subject.extract('foo : bar')).to be_empty
-    end
-  end
-
-  describe "[]" do
-    before { url.save }
-
-    it "should query URLs using URIs" do
-      expect(described_class[uri]).to be == url
-    end
-
-    it "should query URLs using Strings" do
-      expect(described_class[uri.to_s]).to be == url
-    end
-
-    it "should still treat Integer arguments as indexes" do
-      expect(described_class[0]).to be == url
-    end
-
-    after { url.destroy }
-  end
-
-  describe "from" do
-    subject { described_class.from(uri) }
-
-    it "should parse URL schemes" do
-      expect(subject.scheme).not_to be_nil
-      expect(subject.scheme.name).to be == scheme
-    end
-
-    it "should parse host names" do
-      expect(subject.host_name.address).to be == host_name
-    end
-
-    it "should parse port numbers" do
-      expect(subject.port.number).to be == port
-    end
-
-    it "should parse paths" do
-      expect(subject.path).to be == path
-    end
-
-    it "should parse query strings" do
-      expect(subject.query_string).to be == query_string
-    end
-
-    it "should parse URL fragments" do
-      expect(subject.fragment).to be == fragment
-    end
-
-    it "should normalize the paths of HTTP URIs" do
-      uri = URI('http://www.example.com')
-      url = described_class.from(uri)
-
-      expect(url.path).to be == '/'
-    end
-  end
-
-  describe "#host" do
-    subject do
-      described_class.new(:host_name => {:address => host_name})
-    end
-
-    it "should return the URI host String" do
-      expect(subject.host).to be == host_name
-    end
-  end
-
-  describe "#to_uri" do
-    subject { url.to_uri }
-
-    it "should convert the scheme" do
-      expect(subject.scheme).to be == scheme
-    end
-    
-    it "should convert the host name" do
-      expect(subject.host).to be == host_name
-    end
-
-    it "should convert the port number" do
-      expect(subject.port).to be == port
-    end
-
-    it "should convert the path" do
-      expect(subject.path).to be == path
-    end
-
-    it "should convert the query string" do
-      expect(subject.query).to be == query_string
-    end
-
-    it "should omit the query string if there are no query params" do
-      new_url = described_class.parse('https://www.example.com:8080/path')
-      new_uri = new_url.to_uri
-
-      expect(new_uri.query).to be_nil
-    end
-
-    it "should convert the fragment" do
-      expect(subject.fragment).to be == fragment
-    end
-  end
-
-  describe "#to_s" do
-    subject { url.to_s }
-
-    it "should convert the URL back into a String URI" do
-      expect(subject).to be == uri.to_s
-    end
-  end
-
-  describe "#inspect" do
-    subject { url.inspect }
-
-    it "should include the full URL" do
-      expect(subject).to include(uri.to_s)
-    end
-  end
-end

data/spec/vendor_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/vendor'
-
-describe Vendor do
-  let(:name) { 'TestCo' }
-
-  subject { described_class.new(:name => name) }
-
-  describe "validations" do
-    it "should require name attribute" do
-      product = described_class.new
-      expect(product).not_to be_valid
-
-      product.name = name
-      expect(product).to be_valid
-    end
-  end
-
-  describe "#to_s" do
-    it "should include the vendor name" do
-      expect(subject.to_s).to eq(name)
-    end
-  end
-end