ronin-support 0.5.1 → 1.0.0.beta1

data/spec/formatting/html/string_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/html/string'
-
-describe String do
-  subject { "one & two" }
-
-  it "should provide String#html_escape" do
-    should respond_to(:html_escape)
-  end
-
-  it "should provide String#html_unescape" do
-    should respond_to(:html_unescape)
-  end
-
-  it "should provide String#format_html" do
-    should respond_to(:format_html)
-  end
-
-  it "should provide String#js_escape" do
-    should respond_to(:js_escape)
-  end
-
-  it "should provide String#js_unescape" do
-    should respond_to(:js_unescape)
-  end
-
-  it "should provide String#format_js" do
-    should respond_to(:format_js)
-  end
-
-  describe "#html_escape" do
-    let(:html_escaped) { "one & two" }
-
-    it "should HTML escape itself" do
-      subject.html_escape.should == html_escaped
-    end
-  end
-
-  describe "#html_unescape" do
-    let(:html_escaped) { "one & two" }
-
-    it "should HTML unescape itself" do
-      html_escaped.html_unescape.should == subject
-    end
-  end
-
-  describe "#format_html" do
-    let(:formatted_html) do
-      "one & two"
-    end
-
-    it "should HTML format all chars" do
-      subject.format_html.should == formatted_html
-    end
-  end
-
-  describe "#js_escape" do
-    let(:special_chars) { "\t\n\r" }
-    let(:escaped_special_chars) { '\t\n\r' }
-
-    let(:normal_chars) { "abc" }
-
-    it "should escape special JavaScript characters" do
-      special_chars.js_escape.should == escaped_special_chars
-    end
-
-    it "should ignore normal characters" do
-      normal_chars.js_escape.should == normal_chars
-    end
-  end
-
-  describe "#js_unescape" do
-    let(:js_unicode) do
-      "%u006F%u006E%u0065%u0020%u0026%u0020%u0074%u0077%u006F"
-    end
-    let(:js_hex) { "%6F%6E%65%20%26%20%74%77%6F" }
-    let(:js_mixed) { "%u6F%u6E%u65 %26 two" }
-
-    it "should unescape JavaScript unicode characters" do
-      js_unicode.js_unescape.should == subject
-    end
-
-    it "should unescape JavaScript hex characters" do
-      js_hex.js_unescape.should == subject
-    end
-
-    it "should unescape backslash-escaped characters" do
-      "\\b\\t\\n\\f\\r\\\"\\\\".js_unescape.should == "\b\t\n\f\r\"\\"
-    end
-
-    it "should ignore non-escaped characters" do
-      js_mixed.js_unescape.should == subject
-    end
-  end
-
-  describe "#format_js" do
-    let(:js_formatted) { '\x6F\x6E\x65\x20\x26\x20\x74\x77\x6F' }
-
-    it "should JavaScript escape all characters" do
-      subject.format_js.should == js_formatted
-    end
-  end
-end

data/spec/formatting/http/integer_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/http/integer'
-
-describe Integer do
-  subject { 0x20 }
-
-  it "should provide String#uri_encode" do
-    should respond_to(:uri_encode)
-  end
-
-  it "should provide String#uri_escape" do
-    should respond_to(:uri_escape)
-  end
-
-  it "should provide String#format_http" do
-    should respond_to(:format_http)
-  end
-
-  describe "#uri_encode" do
-    let(:uri_encoded) { '%20' }
-
-    it "should URI encode itself" do
-      subject.uri_encode.should == uri_encoded
-    end
-  end
-
-  describe "#uri_escape" do
-    let(:uri_escaped) { '+' }
-
-    it "should URI escape itself" do
-      subject.uri_escape.should == uri_escaped
-    end
-  end
-
-  describe "#format_http" do
-    let(:http_formatted) { '%20' }
-
-    it "should format the byte" do
-      subject.format_http.should == http_formatted
-    end
-  end
-end

data/spec/formatting/http/string_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/http/string'
-
-describe String do
-  subject { "hello" }
-
-  it "should provide String#uri_encode" do
-    should respond_to(:uri_encode)
-  end
-
-  it "should provide String#uri_decode" do
-    should respond_to(:uri_decode)
-  end
-
-  it "should provide String#uri_escape" do
-    should respond_to(:uri_escape)
-  end
-
-  it "should provide String#uri_unescape" do
-    should respond_to(:uri_unescape)
-  end
-
-  it "should provide String#format_http" do
-    should respond_to(:format_http)
-  end
-
-  describe "#uri_encode" do
-    subject { "mod % 3" }
-
-    let(:uri_encoded) { "mod%20%25%203" }
-
-    it "should URI encode itself" do
-      subject.uri_encode.should == uri_encoded
-    end
-  end
-
-  describe "#uri_decode" do
-    subject { "mod%20%25%203" }
-
-    let(:uri_decoded) { "mod % 3" }
-
-    it "should URI decode itself" do
-      subject.uri_decode.should == uri_decoded
-    end
-  end
-
-  describe "#uri_escape" do
-    subject { "x + y" }
-
-    let(:uri_escaped) { "x+%2B+y" }
-
-    it "should URI escape itself" do
-      subject.uri_escape.should == uri_escaped
-    end
-  end
-
-  describe "#uri_unescape" do
-    subject { "x+%2B+y" }
-
-    let(:uri_unescaped) { "x + y" }
-
-    it "should URI unescape itself" do
-      subject.uri_unescape.should == uri_unescaped
-    end
-  end
-
-  describe "#format_http" do
-    subject { "mod % 3" }
-
-    let(:http_formatted) { "%6D%6F%64%20%25%20%33" }
-
-    it "should format each byte of the String" do
-      subject.format_http.should == http_formatted
-    end
-  end
-end

data/spec/formatting/sql/string_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/sql/string'
-
-describe String do
-  before(:all) do
-    @string = '/etc/passwd'
-    @sql_encoded = '0x2f6574632f706173737764'
-    @string_with_quotes = %{"O'Brian"}
-  end
-
-  it "should provide the #sql_escape method" do
-    @string.should respond_to(:sql_escape)
-  end
-
-  it "should provide the #sql_encode method" do
-    @string.should respond_to(:sql_encode)
-  end
-
-  it "should provide the #sql_decode method" do
-    @string.should respond_to(:sql_decode)
-  end
-
-  describe "#sql_escape" do
-    it "should be able to single-quote escape" do
-      @string_with_quotes.sql_escape(:single).should == %{'"O''Brian"'}
-    end
-
-    it "should be able to double-quote escape" do
-      @string_with_quotes.sql_escape(:double).should == %{"""O'Brian"""}
-    end
-  end
-
-  describe "#sql_encode" do
-    it "should be able to be SQL-hex encoded" do
-      @string.sql_encode.should == @sql_encoded
-    end
-
-    it "should return an empty String if empty" do
-      ''.sql_encode.should == ''
-    end
-  end
-
-  describe "#sql_decode" do
-    it "should be able to be SQL-hex decoded" do
-      encoded = @string.sql_encode
-
-      encoded.should == @sql_encoded
-      encoded.sql_decode.should == @string
-    end
-
-    it "should be able to decode SQL comma-escaping" do
-      "'Conan O''Brian'".sql_decode.should == "Conan O'Brian"
-    end
-  end
-
-  describe "#sql_inject" do
-    context "when there is a leading quote character" do
-      it "should remove the first and last quote character" do
-        "'1' OR '1'='1'".sql_inject.should == "1' OR '1'='1"
-      end
-
-      context "when there is no matching leading/trailing quote characters" do
-        it "should comment-terminate the String" do
-          "'1' OR 1=1".sql_inject.should == "1' OR 1=1--"
-        end
-      end
-    end
-
-    context "when there is no leading quote character" do
-      it "should not modify the String" do
-        "1 OR 1=1".sql_inject.should == "1 OR 1=1"
-      end
-    end
-  end
-end

data/spec/formatting/text/array_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/text'
-
-describe Array do
-  subject { [] }
-
-  let(:byte_array) { [0x41, 0x41, 0x20] }
-  let(:char_array) { ['A', 'A', ' '] }
-  let(:mixed_array) { ['AA', 0x20] }
-  let(:string) { 'AA ' }
-
-  it "should provide Array#bytes" do
-    should respond_to(:bytes)
-  end
-
-  it "should provide Array#chars" do
-    should respond_to(:chars)
-  end
-
-  it "should provide Array#char_string" do
-    should respond_to(:char_string)
-  end
-
-  it "should provide Array#hex_chars" do
-    should respond_to(:hex_chars)
-  end
-
-  it "should provide Array#hex_integers" do
-    should respond_to(:hex_integers)
-  end
-
-  describe "#bytes" do
-    it "should convert an Array of bytes to an Array of bytes" do
-      byte_array.bytes.should == byte_array
-    end
-
-    it "should convert an Array of chars to an Array of bytes" do
-      char_array.bytes.should == byte_array
-    end
-
-    it "should safely handle mixed byte/char/string Arrays" do
-      mixed_array.bytes.should == byte_array
-    end
-  end
-
-  describe "#chars" do
-    it "should convert an Array of bytes to an Array of chars" do
-      byte_array.chars.should == char_array
-    end
-
-    it "should safely convert an Array of chars to an Array of chars" do
-      char_array.chars.should == char_array
-    end
-
-    it "should safely handle mixed byte/char/string Arrays" do
-      mixed_array.chars.should == char_array
-    end
-  end
-
-  describe "#char_string" do
-    it "should convert an Array of bytes to a String" do
-      byte_array.char_string.should == string
-    end
-
-    it "should convert an Array of chars to a String" do
-      char_array.char_string.should == string
-    end
-
-    it "should safely handle mixed byte/char/string Arrays" do
-      mixed_array.char_string.should == string
-    end
-  end
-
-  describe "#hex_chars" do
-    let(:hex_chars) { ['\x41', '\x41', '\x20'] }
-
-    it "should convert an Array of bytes into hexadecimal chars" do
-      byte_array.hex_chars.should == hex_chars
-    end
-
-    it "should convert an Array of chars into hexadecimal chars" do
-      char_array.hex_chars.should == hex_chars
-    end
-
-    it "should safely handle mixed byte/char/string Arrays" do
-      mixed_array.hex_chars.should == hex_chars
-    end
-  end
-
-  describe "#hex_integers" do
-    let(:hex_integers) { ['0x41', '0x41', '0x20'] }
-
-    it "should convert an Array of bytes into hexadecimal integers" do
-      byte_array.hex_integers.should == hex_integers
-    end
-
-    it "should convert an Array of chars into hexadecimal integers" do
-      char_array.hex_integers.should == hex_integers
-    end
-
-    it "should safely handle mixed byte/char/string Arrays" do
-      mixed_array.hex_integers.should == hex_integers
-    end
-  end
-end

data/spec/formatting/text/string_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/text'
-
-describe String do
-  subject { "hello" }
-
-  it "should provide String#format_chars" do
-    should respond_to(:format_chars)
-  end
-
-  it "should provide String#format_bytes" do
-    should respond_to(:format_bytes)
-  end
-
-  it "should provide String#random_case" do
-    should respond_to(:random_case)
-  end
-
-  it "should provide String#insert_before" do
-    should respond_to(:insert_before)
-  end
-
-  it "should provide String#insert_after" do
-    should respond_to(:insert_after)
-  end
-
-  it "should provide String#escape" do
-    should respond_to(:escape)
-  end
-
-  it "should provide String#unescape" do
-    should respond_to(:unescape)
-  end
-
-  describe "#format_bytes" do
-    it "should format each byte in the String" do
-      subject.format_bytes { |b|
-        sprintf("%%%x",b)
-      }.should == "%68%65%6c%6c%6f"
-    end
-
-    it "should format specific bytes in a String" do
-      subject.format_bytes(:include => [104, 108]) { |b|
-        b - 32
-      }.should == 'HeLLo'
-    end
-
-    it "should not format specific bytes in a String" do
-      subject.format_bytes(:exclude => [101, 111]) { |b|
-        b - 32
-      }.should == 'HeLLo'
-    end
-
-    it "should format ranges of bytes in a String" do
-      subject.format_bytes(:include => (104..108)) { |b|
-        b - 32
-      }.should == 'HeLLo'
-    end
-
-    it "should not format ranges of bytes in a String" do
-      subject.format_bytes(:exclude => (104..108)) { |b|
-        b - 32
-      }.should == 'hEllO'
-    end
-  end
-
-  describe "#format_chars" do
-    it "should format each character in the String" do
-      subject.format_chars { |c|
-        "#{c}."
-      }.should == "h.e.l.l.o."
-    end
-
-    it "should format specific chars in a String" do
-      subject.format_chars(:include => ['h', 'l']) { |c|
-        c.upcase
-      }.should == 'HeLLo'
-    end
-
-    it "should not format specific chars in a String" do
-      subject.format_chars(:exclude => ['h', 'l']) { |c|
-        c.upcase
-      }.should == 'hEllO'
-    end
-
-    it "should format ranges of chars in a String" do
-      subject.format_chars(:include => /[h-l]/) { |c|
-        c.upcase
-      }.should == 'HeLLo'
-    end
-
-    it "should not format ranges of chars in a String" do
-      subject.format_chars(:exclude => /[h-l]/) { |c|
-        c.upcase
-      }.should == 'hEllO'
-    end
-  end
-
-  describe "#random_case" do
-    it "should capitalize each character when :probability is 1.0" do
-      new_string = subject.random_case(:probability => 1.0)
-
-      subject.upcase.should == new_string
-    end
-
-    it "should not capitalize any characters when :probability is 0.0" do
-      new_string = subject.random_case(:probability => 0.0)
-
-      subject.should == new_string
-    end
-  end
-
-  describe "#insert_before" do
-    it "should inject data before a matched String" do
-      subject.insert_before('ll','x').should == "hexllo"
-    end
-
-    it "should inject data before a matched Regexp" do
-      subject.insert_before(/l+/,'x').should == "hexllo"
-    end
-
-    it "should not inject data if no matches are found" do
-      subject.insert_before(/x/,'x').should == subject
-    end
-  end
-
-  describe "#insert_after" do
-    it "should inject data after a matched String" do
-      subject.insert_after('ll','x').should == "hellxo"
-    end
-
-    it "should inject data after a matched Regexp" do
-      subject.insert_after(/l+/,'x').should == "hellxo"
-    end
-
-    it "should not inject data if no matches are found" do
-      subject.insert_after(/x/,'x').should == subject
-    end
-  end
-
-  describe "#unescape" do
-    it "should not unescape a normal String" do
-      "hello".unescape.should == "hello"
-    end
-
-    it "should unescape a hex String" do
-      "\\x68\\x65\\x6c\\x6c\\x6f\\x4e".unescape.should == "hello\x4e"
-    end
-
-    it "should unescape an octal String" do
-      "hello\012".unescape.should == "hello\n"
-    end
-
-    it "should unescape control characters" do
-      "hello\\n".unescape.should == "hello\n"
-    end
-
-    it "should unescape normal characters" do
-      "hell\\o".unescape.should == "hello"
-    end
-  end
-end

data/spec/fuzzing/extensions/string_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/extensions/string'
-
-describe String do
-  it "should provide String.generate" do
-    described_class.should respond_to(:generate)
-  end
-
-  it "should provide String#repeating" do
-    subject.should respond_to(:repeating)
-  end
-
-  it "should provide String#fuzz" do
-    subject.should respond_to(:fuzz)
-  end
-
-  it "should provide String#mutate" do
-    subject.should respond_to(:mutate)
-  end
-
-  describe "generate" do
-    subject { described_class }
-
-    it "should generate Strings from a template" do
-      strings = subject.generate([:numeric, 2]).to_a
-
-      strings.grep(/^[0-9]{2}$/).should == strings
-    end
-  end
-
-  describe "#repeating" do
-    subject { 'A' }
-
-    context "when n is an Integer" do
-      let(:n) { 100 }
-
-      it "should multiply the String by n" do
-        subject.repeating(n).should == (subject * n)
-      end
-    end
-
-    context "when n is Enumerable" do
-      let(:n) { [128, 512, 1024] }
-
-      it "should repeat the String by each length" do
-        strings = subject.repeating(n).to_a
-
-        strings.should == n.map { |length| subject * length }
-      end
-    end
-  end
-
-  describe "#fuzz" do
-    subject { "foo bar" }
-
-    it "should apply each fuzzing rule individually" do
-      strings = subject.fuzz(/o/ => ['O', '0'], /a/ => ['A', '@']).to_a
-      
-      strings.should =~ [
-        "fOo bar",
-        "f0o bar",
-        "foO bar",
-        "fo0 bar",
-        "foo bAr",
-        "foo b@r"
-      ]
-    end
-  end
-
-  describe "#mutate" do
-    subject { "foo bar" }
-
-    it "should apply every combination of mutation rules" do
-      strings = subject.mutate(/o/ => ['0'], /a/ => ['@']).to_a
-
-      strings.should =~ [
-        "f0o bar",
-        "fo0 bar",
-        "f00 bar",
-        "foo b@r",
-        "f0o b@r",
-        "fo0 b@r",
-        "f00 b@r"
-      ]
-    end
-  end
-end