ronin-support 0.5.1 → 1.0.0.beta1

data/spec/fuzzing/fuzzer_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/fuzzer'
-
-describe Fuzzing::Fuzzer do
-  let(:string) { 'GET /one/two/three' }
-
-  describe "#initialize" do
-    subject { described_class }
-
-    context "patterns" do
-      let(:substitutions) { ['bar'] }
-
-      it "should accept Regexps" do
-        fuzzer = subject.new(/foo/ => substitutions)
-
-        fuzzer.rules.should have_key(/foo/)
-      end
-
-      context "when given Strings" do
-        subject { described_class.new('foo' => substitutions) }
-
-        it "should convert to Regexp" do
-          subject.rules.should have_key(/foo/)
-        end
-      end
-
-      context "when given Symbols" do
-        subject { described_class.new(:word => substitutions) }
-
-        it "should lookup the Regexp constant" do
-          subject.rules.should have_key(Regexp::WORD)
-        end
-      end
-
-      context "otherwise" do
-        it "should raise a TypeError" do
-          lambda {
-            subject.new(Object.new => substitutions)
-          }.should raise_error(TypeError)
-        end
-      end
-    end
-
-    context "substitutions" do
-      let(:pattern) { /foo/ }
-
-      it "should accept Enumerable values" do
-        fuzzer = subject.new(pattern => ['bar'])
-
-        fuzzer.rules[pattern].should == ['bar']
-      end
-
-      context "when given Symbols" do
-        subject { described_class.new(pattern => :bad_strings) }
-
-        it "should map to an Enumerator for a Fuzzing method" do
-          subject.rules[pattern].should be_kind_of(Enumerable)
-        end
-      end
-
-      context "otherwise" do
-        it "should raise a TypeError" do
-          lambda {
-            subject.new(pattern => Object.new)
-          }.should raise_error(TypeError)
-        end
-      end
-    end
-  end
-
-  describe "#each" do
-    let(:string) { "foo bar" }
-
-    subject { described_class.new(/o/ => ['O', '0'], /a/ => ['A', '@']) }
-
-    it "should apply each fuzzing rule individually" do
-      subject.each(string).to_a.should =~ [
-        "fOo bar",
-        "f0o bar",
-        "foO bar",
-        "fo0 bar",
-        "foo bAr",
-        "foo b@r"
-      ]
-    end
-
-    context "when mutations contain Integers" do
-      subject { described_class.new(/o/ => [48]) }
-
-      it "should convert them to characters" do
-        subject.each(string).to_a.should =~ [
-          "f0o bar",
-          "fo0 bar"
-        ]
-      end
-    end
-
-    context "when mutations contain Procs" do
-      subject { described_class.new(/o/ => [lambda { |str| str.upcase }]) }
-
-      it "should call them with the matched String" do
-        subject.each(string).to_a.should =~ [
-          "fOo bar",
-          "foO bar"
-        ]
-      end
-    end
-  end
-end

data/spec/fuzzing/fuzzing_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/fuzzing'
-
-describe Fuzzing do
-  describe "[]" do
-    let(:method) { :bad_strings }
-
-    it "should return Enumerators for fuzzing methods" do
-      subject[method].should be_kind_of(Enumerable)
-    end
-
-    it "should raise NoMethodError for unknown methods" do
-      lambda {
-        subject[:foo]
-      }.should raise_error(NoMethodError)
-    end
-
-    it "should not allow accessing inherited methods" do
-      lambda {
-        subject[:instance_eval]
-      }.should raise_error(NoMethodError)
-    end
-  end
-end

data/spec/fuzzing/mutator_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/mutator'
-
-describe Fuzzing::Mutator do
-  let(:string) { 'GET /one/two/three' }
-
-  describe "#initialize" do
-    subject { described_class }
-
-    context "patterns" do
-      let(:substitutions) { ['bar'] }
-
-      it "should accept Regexps" do
-        fuzzer = subject.new(/foo/ => substitutions)
-
-        fuzzer.rules.should have_key(/foo/)
-      end
-
-      context "when given Strings" do
-        subject { described_class.new('foo' => substitutions) }
-
-        it "should convert to Regexp" do
-          subject.rules.should have_key(/foo/)
-        end
-      end
-
-      context "when given Symbols" do
-        subject { described_class.new(:word => substitutions) }
-
-        it "should lookup the Regexp constant" do
-          subject.rules.should have_key(Regexp::WORD)
-        end
-      end
-
-      context "otherwise" do
-        it "should raise a TypeError" do
-          lambda {
-            subject.new(Object.new => substitutions)
-          }.should raise_error(TypeError)
-        end
-      end
-    end
-
-    context "mutations" do
-      let(:pattern) { /foo/ }
-
-      it "should accept Enumerable values" do
-        fuzzer = subject.new(pattern => ['bar'])
-
-        fuzzer.rules[pattern].should == ['bar']
-      end
-
-      context "when given Symbols" do
-        subject { described_class.new(pattern => :bad_strings) }
-
-        it "should map to an Enumerator for a Fuzzing method" do
-          subject.rules[pattern].should be_kind_of(Enumerable)
-        end
-      end
-
-      context "otherwise" do
-        it "should raise a TypeError" do
-          lambda {
-            subject.new(pattern => Object.new)
-          }.should raise_error(TypeError)
-        end
-      end
-    end
-  end
-
-  describe "#each" do
-    let(:string) { "foo bar" }
-
-    subject { described_class.new(/o/ => ['0'], /a/ => ['@']) }
-
-    it "should apply every combination of mutation rules" do
-      subject.each(string).to_a.should =~ [
-        "f0o bar",
-        "fo0 bar",
-        "f00 bar",
-        "foo b@r",
-        "f0o b@r",
-        "fo0 b@r",
-        "f00 b@r"
-      ]
-    end
-
-    context "when mutations contain Integers" do
-      subject { described_class.new(/o/ => [48]) }
-
-      it "should convert them to characters" do
-        subject.each(string).to_a.should =~ [
-          "f0o bar",
-          "fo0 bar",
-          "f00 bar"
-        ]
-      end
-    end
-
-    context "when mutations contain Procs" do
-      subject { described_class.new(/o/ => [lambda { |str| str.upcase }]) }
-
-      it "should call them with the matched String" do
-        subject.each(string).to_a.should =~ [
-          "fOo bar",
-          "foO bar",
-          "fOO bar"
-        ]
-      end
-    end
-  end
-end

data/spec/fuzzing/repeater_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/repeater'
-
-describe Fuzzing::Repeater do
-  describe "#initialize" do
-    subject { described_class }
-
-    context "when lengths is an Integer" do
-      it "should coerce lengths to an Enumerable" do
-        repeator = subject.new(10)
-
-        repeator.lengths.should be_kind_of(Enumerable)
-      end
-    end
-
-    context "when lengths is not Enumerable or an Integer" do
-      it "should raise a TypeError" do
-        lambda {
-          subject.new(Object.new)
-        }.should raise_error(TypeError)
-      end
-    end
-  end
-
-  describe "#each" do
-    let(:repeatable) { 'A' }
-
-    context "when lengths was an Integer" do
-      let(:length) { 10 }
-
-      subject { described_class.new(length) }
-
-      it "should yield one repeated value" do
-        values = subject.each(repeatable).to_a
-        
-        values.should == [repeatable * length]
-      end
-    end
-
-    context "when lengths was Enumerable" do
-      let(:lengths) { (1..4) }
-
-      subject { described_class.new(lengths) }
-
-      it "should yield repeated values for each length" do
-        values = subject.each(repeatable).to_a.should
-
-        values.should == [
-          repeatable * 1,
-          repeatable * 2,
-          repeatable * 3,
-          repeatable * 4
-        ]
-      end
-    end
-  end
-end

data/spec/fuzzing/template_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/template'
-
-describe Fuzzing::Template do
-  subject { described_class }
-
-  it "should generate Strings from CharSets" do
-    strings = subject.new([:lowercase_hexadecimal, :numeric]).to_a
-
-    strings.grep(/^[0-9a-f][0-9]$/).should == strings
-  end
-
-  it "should generate Strings from lengths of CharSets" do
-    strings = subject.new([[:numeric, 2]]).to_a
-
-    strings.grep(/^[0-9]{2}$/).should == strings
-  end
-
-  it "should generate Strings from varying lengths of CharSets" do
-    strings = subject.new([[:numeric, 1..2]]).to_a
-
-    strings.grep(/^[0-9]{1,2}$/).should == strings
-  end
-
-  it "should generate Strings from custom CharSets" do
-    strings = subject.new([[%w[a b c], 2]]).to_a
-
-    strings.grep(/^[abc]{2}$/).should == strings
-  end
-
-  it "should generate Strings containing known Strings" do
-    strings = subject.new(['foo', [%w[a b c], 2]]).to_a
-
-    strings.grep(/^foo[abc]{2}$/).should == strings
-  end
-
-  it "should raise a TypeError for non String, Symbol, Enumerable CharSets" do
-    lambda {
-      subject.new([[Object.new, 2]]).to_a
-    }.should raise_error(TypeError)
-  end
-
-  it "should raise an ArgumentError for unknown CharSets" do
-    lambda {
-      subject.new([[:foo_bar, 2]]).to_a
-    }.should raise_error(ArgumentError)
-  end
-
-  it "should raise a TypeError for non Integer,Array,Range lengths" do
-    lambda {
-      subject.new([[:numeric, 'foo']]).to_a
-    }.should raise_error(TypeError)
-  end
-end

data/spec/mixin_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-require 'ronin/mixin'
-
-module Mixins
-  module Test1
-  end
-
-  module Test2
-  end
-end
-
-describe Mixin do
-  subject do
-    Module.new do
-      include Mixin
-
-      mixin Mixins::Test1, Mixins::Test2
-      mixin { @var = 1 }
-    end
-  end
-
-  context "when included" do
-    before(:all) do
-      @base = Class.new
-      @base.send :include, subject
-    end
-
-    it "should include the mixed in modules" do
-      @base.should include(Mixins::Test1)
-      @base.should include(Mixins::Test2)
-    end
-
-    it "should evaluate the mixin block" do
-      @base.instance_variable_get("@var").should == 1
-    end
-  end
-
-  context "when extended" do
-    before(:all) do
-      @base = Object.new
-      @base.send :extend, subject
-    end
-
-    it "should extend the mixed in modules" do
-      @base.should be_kind_of(Mixins::Test1)
-      @base.should be_kind_of(Mixins::Test2)
-    end
-
-    it "should evaluate the mixin block" do
-      @base.instance_variable_get("@var").should == 1
-    end
-  end
-end

data/spec/network/dns_spec.rb

@@ -1,201 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/dns'
-
-require 'ipaddr'
-
-describe Network::DNS do
-  let(:server) { '4.2.2.1' }
-
-  describe "nameserver" do
-    it "should be nil by default" do
-      subject.nameserver.should be_nil
-    end
-  end
-
-  describe "nameserver=" do
-    it "should accept Strings" do
-      subject.nameserver = server
-
-      subject.nameserver.should == server
-    end
-
-    it "should accept nil" do
-      subject.nameserver = server
-      subject.nameserver = nil
-
-      subject.nameserver.should be_nil
-    end
-
-    it "should convert non-nil values to Strings" do
-      subject.nameserver = IPAddr.new(server)
-
-      subject.nameserver.should == server
-    end
-  end
-
-  describe "#dns_resolver" do
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    it "should return Resolv when passed no nameserver" do
-      subject.dns_resolver(nil).should == Resolv
-    end
-
-    it "should return Resolv::DNS when passed a nameserver" do
-      subject.dns_resolver(server).should be_kind_of(Resolv::DNS)
-    end
-  end
-
-  describe "helper methods", :network do
-    let(:hostname)         { 'example.com' }
-    let(:bad_hostname)     { 'foo.bar' }
-    let(:address)          { '192.0.43.10' }
-    let(:bad_address)      { '0.0.0.0' }
-    let(:reverse_hostname) { '43-10.any.icann.org' }
-
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    describe "#dns_lookup" do
-      it "should lookup the address for a hostname" do
-        subject.dns_lookup(hostname).should == address
-      end
-
-      it "should return nil for unknown hostnames" do
-        subject.dns_lookup(bad_hostname).should be_nil
-      end
-
-      it "should accept non-String hostnames" do
-        subject.dns_lookup(hostname.to_sym).should == address
-      end
-
-      it "should accept an additional nameserver argument" do
-        subject.dns_lookup(hostname,server).should == address
-      end
-
-      context "when given a block" do
-        it "should yield the resolved address" do
-          resolved_address = nil
-
-          subject.dns_lookup(hostname) do |address|
-            resolved_address = address
-          end
-
-          resolved_address.should == address
-        end
-
-        it "should not yield unresolved addresses" do
-          resolved_address = nil
-
-          subject.dns_lookup(bad_hostname) do |address|
-            resolved_address = address
-          end
-
-          resolved_address.should be_nil
-        end
-      end
-    end
-
-    describe "#dns_lookup_all" do
-      it "should lookup all addresses for a hostname" do
-        subject.dns_lookup_all(hostname).should include(address)
-      end
-
-      it "should return an empty Array for unknown hostnames" do
-        subject.dns_lookup_all(bad_hostname).should == []
-      end
-
-      it "should accept non-String hostnames" do
-        subject.dns_lookup_all(hostname.to_sym).should include(address)
-      end
-
-      it "should accept an additional nameserver argument" do
-        subject.dns_lookup_all(hostname,server).should include(address)
-      end
-
-      context "when given a block" do
-        it "should yield the resolved address" do
-          subject.enum_for(:dns_lookup,hostname).to_a.should == [address]
-        end
-
-        it "should not yield unresolved addresses" do
-          subject.enum_for(:dns_lookup,bad_hostname).to_a.should == []
-        end
-      end
-    end
-
-    describe "#dns_reverse_lookup" do
-      it "should lookup the address for a hostname" do
-        subject.dns_reverse_lookup(address).should == reverse_hostname
-      end
-
-      it "should return nil for unknown hostnames" do
-        subject.dns_reverse_lookup(bad_address).should be_nil
-      end
-
-      it "should accept non-String addresses" do
-        subject.dns_reverse_lookup(IPAddr.new(address)).should == reverse_hostname
-      end
-
-      it "should accept an additional nameserver argument" do
-        subject.dns_reverse_lookup(address,server).should == reverse_hostname
-      end
-
-      context "when given a block" do
-        it "should yield the resolved hostname" do
-          resolved_hostname = nil
-
-          subject.dns_reverse_lookup(address) do |hostname|
-            resolved_hostname = hostname
-          end
-
-          resolved_hostname.should == reverse_hostname
-        end
-
-        it "should not yield unresolved hostnames" do
-          resolved_hostname = nil
-
-          subject.dns_reverse_lookup(bad_address) do |hostname|
-            resolved_hostname = hostname
-          end
-
-          resolved_hostname.should be_nil
-        end
-      end
-    end
-
-    describe "#dns_reverse_lookup_all" do
-      it "should lookup all addresses for a hostname" do
-        subject.dns_reverse_lookup_all(address).should include(reverse_hostname)
-      end
-
-      it "should return an empty Array for unknown hostnames" do
-        subject.dns_reverse_lookup_all(bad_address).should == []
-      end
-
-      it "should accept non-String addresses" do
-        subject.dns_reverse_lookup_all(IPAddr.new(address)).should include(reverse_hostname)
-      end
-
-      it "should accept an additional nameserver argument" do
-        subject.dns_reverse_lookup_all(address,server).should include(reverse_hostname)
-      end
-
-      context "when given a block" do
-        it "should yield the resolved hostnames" do
-          subject.enum_for(:dns_reverse_lookup_all,address).to_a.should == [reverse_hostname]
-        end
-
-        it "should not yield unresolved hostnames" do
-          subject.enum_for(:dns_reverse_lookup_all,bad_address).to_a.should == []
-        end
-      end
-    end
-  end
-end

data/spec/network/ftp_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/ftp'
-
-describe Network::FTP do
-  describe "helpers", :network do
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    let(:host) { 'ftp.kernel.org' }
-
-    describe "#ftp_connect" do
-      it "should return a Net::FTP object" do
-        ftp = subject.ftp_connect(host)
-
-        ftp.should be_kind_of(Net::FTP)
-        ftp.close
-      end
-
-      it "should connect to an FTP service" do
-        ftp = subject.ftp_connect(host)
-
-        ftp.should_not be_closed
-        ftp.close
-      end
-
-      describe ":passive" do
-        it "should set passive mode by default" do
-          ftp = subject.ftp_connect(host)
-
-          ftp.passive.should be_true
-          ftp.close
-        end
-
-        it "should allow disabling passive mode" do
-          ftp = subject.ftp_connect(host, :passive => false)
-
-          ftp.passive.should be_false
-          ftp.close
-        end
-      end
-
-      context "when given a block" do
-        it "should yield the new Net::FTP object" do
-          ftp = subject.ftp_connect(host) do |ftp|
-            ftp.should be_kind_of(Net::FTP)
-          end
-
-          ftp.close
-        end
-      end
-    end
-
-    describe "#ftp_session" do
-      it "should yield a new Net::FTP object" do
-        yielded_ftp = nil
-
-        subject.ftp_session(host) do |ftp|
-          yielded_ftp = ftp
-        end
-
-        yielded_ftp.should be_kind_of(Net::FTP)
-      end
-
-      it "should close the FTP session after yielding it" do
-        session  = nil
-        was_open = nil
-
-        subject.ftp_session(host) do |ftp|
-          session   = ftp
-          was_open  = !ftp.closed?
-        end
-
-        was_open.should == true
-        session.should be_closed
-      end
-    end
-  end
-end