ronin-support 0.4.1 → 0.5.2

data/spec/formatting/html/string_spec.rb

@@ -32,7 +32,7 @@ describe String do
     let(:html_escaped) { "one & two" }
 
     it "should HTML escape itself" do
-      subject.html_escape.should == html_escaped
+      expect(subject.html_escape).to eq(html_escaped)
     end
   end
 
@@ -40,7 +40,7 @@ describe String do
     let(:html_escaped) { "one & two" }
 
     it "should HTML unescape itself" do
-      html_escaped.html_unescape.should == subject
+      expect(html_escaped.html_unescape).to eq(subject)
     end
   end
 
@@ -50,7 +50,7 @@ describe String do
     end
 
     it "should HTML format all chars" do
-      subject.format_html.should == formatted_html
+      expect(subject.format_html).to eq(formatted_html)
     end
   end
 
@@ -61,11 +61,11 @@ describe String do
     let(:normal_chars) { "abc" }
 
     it "should escape special JavaScript characters" do
-      special_chars.js_escape.should == escaped_special_chars
+      expect(special_chars.js_escape).to eq(escaped_special_chars)
     end
 
     it "should ignore normal characters" do
-      normal_chars.js_escape.should == normal_chars
+      expect(normal_chars.js_escape).to eq(normal_chars)
     end
   end
 
@@ -77,19 +77,19 @@ describe String do
     let(:js_mixed) { "%u6F%u6E%u65 %26 two" }
 
     it "should unescape JavaScript unicode characters" do
-      js_unicode.js_unescape.should == subject
+      expect(js_unicode.js_unescape).to eq(subject)
     end
 
     it "should unescape JavaScript hex characters" do
-      js_hex.js_unescape.should == subject
+      expect(js_hex.js_unescape).to eq(subject)
     end
 
     it "should unescape backslash-escaped characters" do
-      "\\b\\t\\n\\f\\r\\\"\\\\".js_unescape.should == "\b\t\n\f\r\"\\"
+      expect("\\b\\t\\n\\f\\r\\\"\\\\".js_unescape).to eq("\b\t\n\f\r\"\\")
     end
 
     it "should ignore non-escaped characters" do
-      js_mixed.js_unescape.should == subject
+      expect(js_mixed.js_unescape).to eq(subject)
     end
   end
 
@@ -97,7 +97,7 @@ describe String 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
+      expect(subject.format_js).to eq(js_formatted)
     end
   end
 end

data/spec/formatting/http/integer_spec.rb

@@ -20,7 +20,7 @@ describe Integer do
     let(:uri_encoded) { '%20' }
 
     it "should URI encode itself" do
-      subject.uri_encode.should == uri_encoded
+      expect(subject.uri_encode).to eq(uri_encoded)
     end
   end
 
@@ -28,7 +28,7 @@ describe Integer do
     let(:uri_escaped) { '+' }
 
     it "should URI escape itself" do
-      subject.uri_escape.should == uri_escaped
+      expect(subject.uri_escape).to eq(uri_escaped)
     end
   end
 
@@ -36,7 +36,7 @@ describe Integer do
     let(:http_formatted) { '%20' }
 
     it "should format the byte" do
-      subject.format_http.should == http_formatted
+      expect(subject.format_http).to eq(http_formatted)
     end
   end
 end

data/spec/formatting/http/string_spec.rb

@@ -30,7 +30,7 @@ describe String do
     let(:uri_encoded) { "mod%20%25%203" }
 
     it "should URI encode itself" do
-      subject.uri_encode.should == uri_encoded
+      expect(subject.uri_encode).to eq(uri_encoded)
     end
   end
 
@@ -40,7 +40,7 @@ describe String do
     let(:uri_decoded) { "mod % 3" }
 
     it "should URI decode itself" do
-      subject.uri_decode.should == uri_decoded
+      expect(subject.uri_decode).to eq(uri_decoded)
     end
   end
 
@@ -50,7 +50,7 @@ describe String do
     let(:uri_escaped) { "x+%2B+y" }
 
     it "should URI escape itself" do
-      subject.uri_escape.should == uri_escaped
+      expect(subject.uri_escape).to eq(uri_escaped)
     end
   end
 
@@ -60,7 +60,7 @@ describe String do
     let(:uri_unescaped) { "x + y" }
 
     it "should URI unescape itself" do
-      subject.uri_unescape.should == uri_unescaped
+      expect(subject.uri_unescape).to eq(uri_unescaped)
     end
   end
 
@@ -70,7 +70,7 @@ describe String do
     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
+      expect(subject.format_http).to eq(http_formatted)
     end
   end
 end

data/spec/formatting/sql/string_spec.rb

@@ -2,73 +2,75 @@ 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
+  let(:string) {'/etc/passwd' }
+  let(:sql_encoded) { '0x2f6574632f706173737764' }
+  let(:string_with_quotes) { %{"O'Brian"} }
 
   it "should provide the #sql_escape method" do
-    @string.should respond_to(:sql_escape)
+    expect(string).to respond_to(:sql_escape)
   end
 
   it "should provide the #sql_encode method" do
-    @string.should respond_to(:sql_encode)
+    expect(string).to respond_to(:sql_encode)
   end
 
   it "should provide the #sql_decode method" do
-    @string.should respond_to(:sql_decode)
+    expect(string).to 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"'}
+      expect(string_with_quotes.sql_escape(:single)).to eq(%{'"O''Brian"'})
     end
 
     it "should be able to double-quote escape" do
-      @string_with_quotes.sql_escape(:double).should == %{"""O'Brian"""}
+      expect(string_with_quotes.sql_escape(:double)).to eq(%{"""O'Brian"""})
+    end
+
+    it "should be able to tick-mark escape" do
+      expect(string_with_quotes.sql_escape(:tick)).to eq(%{`"O'Brian"`})
     end
   end
 
   describe "#sql_encode" do
     it "should be able to be SQL-hex encoded" do
-      @string.sql_encode.should == @sql_encoded
+      expect(string.sql_encode).to eq(sql_encoded)
     end
 
     it "should return an empty String if empty" do
-      ''.sql_encode.should == ''
+      expect(''.sql_encode).to eq('')
     end
   end
 
   describe "#sql_decode" do
     it "should be able to be SQL-hex decoded" do
-      encoded = @string.sql_encode
+      encoded = string.sql_encode
 
-      encoded.should == @sql_encoded
-      encoded.sql_decode.should == @string
+      expect(encoded).to eq(sql_encoded)
+      expect(encoded.sql_decode).to eq(string)
     end
 
     it "should be able to decode SQL comma-escaping" do
-      "'Conan O''Brian'".sql_decode.should == "Conan O'Brian"
+      expect("'Conan O''Brian'".sql_decode).to eq("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"
+        expect("'1' OR '1'='1'".sql_inject).to eq("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--"
+          expect("'1' OR 1=1".sql_inject).to eq("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"
+        expect("1 OR 1=1".sql_inject).to eq("1 OR 1=1")
       end
     end
   end

data/spec/formatting/text/array_spec.rb

@@ -31,43 +31,43 @@ describe Array do
 
   describe "#bytes" do
     it "should convert an Array of bytes to an Array of bytes" do
-      byte_array.bytes.should == byte_array
+      expect(byte_array.bytes).to eq(byte_array)
     end
 
     it "should convert an Array of chars to an Array of bytes" do
-      char_array.bytes.should == byte_array
+      expect(char_array.bytes).to eq(byte_array)
     end
 
     it "should safely handle mixed byte/char/string Arrays" do
-      mixed_array.bytes.should == byte_array
+      expect(mixed_array.bytes).to eq(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
+      expect(byte_array.chars).to eq(char_array)
     end
 
     it "should safely convert an Array of chars to an Array of chars" do
-      char_array.chars.should == char_array
+      expect(char_array.chars).to eq(char_array)
     end
 
     it "should safely handle mixed byte/char/string Arrays" do
-      mixed_array.chars.should == char_array
+      expect(mixed_array.chars).to eq(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
+      expect(byte_array.char_string).to eq(string)
     end
 
     it "should convert an Array of chars to a String" do
-      char_array.char_string.should == string
+      expect(char_array.char_string).to eq(string)
     end
 
     it "should safely handle mixed byte/char/string Arrays" do
-      mixed_array.char_string.should == string
+      expect(mixed_array.char_string).to eq(string)
     end
   end
 
@@ -75,15 +75,15 @@ describe Array 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
+      expect(byte_array.hex_chars).to eq(hex_chars)
     end
 
     it "should convert an Array of chars into hexadecimal chars" do
-      char_array.hex_chars.should == hex_chars
+      expect(char_array.hex_chars).to eq(hex_chars)
     end
 
     it "should safely handle mixed byte/char/string Arrays" do
-      mixed_array.hex_chars.should == hex_chars
+      expect(mixed_array.hex_chars).to eq(hex_chars)
     end
   end
 
@@ -91,15 +91,15 @@ describe Array 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
+      expect(byte_array.hex_integers).to eq(hex_integers)
     end
 
     it "should convert an Array of chars into hexadecimal integers" do
-      char_array.hex_integers.should == hex_integers
+      expect(char_array.hex_integers).to eq(hex_integers)
     end
 
     it "should safely handle mixed byte/char/string Arrays" do
-      mixed_array.hex_integers.should == hex_integers
+      expect(mixed_array.hex_integers).to eq(hex_integers)
     end
   end
 end

data/spec/formatting/text/string_spec.rb

@@ -24,67 +24,75 @@ describe String 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|
+      expect(subject.format_bytes { |b|
         sprintf("%%%x",b)
-      }.should == "%68%65%6c%6c%6f"
+      }).to eq("%68%65%6c%6c%6f")
     end
 
     it "should format specific bytes in a String" do
-      subject.format_bytes(:include => [104, 108]) { |b|
+      expect(subject.format_bytes(:include => [104, 108]) { |b|
         b - 32
-      }.should == 'HeLLo'
+      }).to eq('HeLLo')
     end
 
     it "should not format specific bytes in a String" do
-      subject.format_bytes(:exclude => [101, 111]) { |b|
+      expect(subject.format_bytes(:exclude => [101, 111]) { |b|
         b - 32
-      }.should == 'HeLLo'
+      }).to eq('HeLLo')
     end
 
     it "should format ranges of bytes in a String" do
-      subject.format_bytes(:include => (104..108)) { |b|
+      expect(subject.format_bytes(:include => (104..108)) { |b|
         b - 32
-      }.should == 'HeLLo'
+      }).to eq('HeLLo')
     end
 
     it "should not format ranges of bytes in a String" do
-      subject.format_bytes(:exclude => (104..108)) { |b|
+      expect(subject.format_bytes(:exclude => (104..108)) { |b|
         b - 32
-      }.should == 'hEllO'
+      }).to eq('hEllO')
     end
   end
 
   describe "#format_chars" do
     it "should format each character in the String" do
-      subject.format_chars { |c|
+      expect(subject.format_chars { |c|
         "#{c}."
-      }.should == "h.e.l.l.o."
+      }).to eq("h.e.l.l.o.")
     end
 
     it "should format specific chars in a String" do
-      subject.format_chars(:include => ['h', 'l']) { |c|
+      expect(subject.format_chars(:include => ['h', 'l']) { |c|
         c.upcase
-      }.should == 'HeLLo'
+      }).to eq('HeLLo')
     end
 
     it "should not format specific chars in a String" do
-      subject.format_chars(:exclude => ['h', 'l']) { |c|
+      expect(subject.format_chars(:exclude => ['h', 'l']) { |c|
         c.upcase
-      }.should == 'hEllO'
+      }).to eq('hEllO')
     end
 
     it "should format ranges of chars in a String" do
-      subject.format_chars(:include => /[h-l]/) { |c|
+      expect(subject.format_chars(:include => /[h-l]/) { |c|
         c.upcase
-      }.should == 'HeLLo'
+      }).to eq('HeLLo')
     end
 
     it "should not format ranges of chars in a String" do
-      subject.format_chars(:exclude => /[h-l]/) { |c|
+      expect(subject.format_chars(:exclude => /[h-l]/) { |c|
         c.upcase
-      }.should == 'hEllO'
+      }).to eq('hEllO')
     end
   end
 
@@ -92,41 +100,63 @@ describe String 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
+      expect(subject.upcase).to eq(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
+      expect(subject).to eq(new_string)
     end
   end
 
   describe "#insert_before" do
     it "should inject data before a matched String" do
-      subject.insert_before('ll','x').should == "hexllo"
+      expect(subject.insert_before('ll','x')).to eq("hexllo")
     end
 
     it "should inject data before a matched Regexp" do
-      subject.insert_before(/l+/,'x').should == "hexllo"
+      expect(subject.insert_before(/l+/,'x')).to eq("hexllo")
     end
 
     it "should not inject data if no matches are found" do
-      subject.insert_before(/x/,'x').should == subject
+      expect(subject.insert_before(/x/,'x')).to eq(subject)
     end
   end
 
   describe "#insert_after" do
     it "should inject data after a matched String" do
-      subject.insert_after('ll','x').should == "hellxo"
+      expect(subject.insert_after('ll','x')).to eq("hellxo")
     end
 
     it "should inject data after a matched Regexp" do
-      subject.insert_after(/l+/,'x').should == "hellxo"
+      expect(subject.insert_after(/l+/,'x')).to eq("hellxo")
     end
 
     it "should not inject data if no matches are found" do
-      subject.insert_after(/x/,'x').should == subject
+      expect(subject.insert_after(/x/,'x')).to eq(subject)
+    end
+  end
+
+  describe "#unescape" do
+    it "should not unescape a normal String" do
+      expect("hello".unescape).to eq("hello")
+    end
+
+    it "should unescape a hex String" do
+      expect("\\x68\\x65\\x6c\\x6c\\x6f\\x4e".unescape).to eq("hello\x4e")
+    end
+
+    it "should unescape an octal String" do
+      expect("hello\012".unescape).to eq("hello\n")
+    end
+
+    it "should unescape control characters" do
+      expect("hello\\n".unescape).to eq("hello\n")
+    end
+
+    it "should unescape normal characters" do
+      expect("hell\\o".unescape).to eq("hello")
     end
   end
 end