ronin-support 0.4.1 → 0.5.2

data/spec/extensions/resolv_spec.rb

@@ -8,11 +8,11 @@ describe Resolv do
     subject { Resolv }
 
     it "should create a new Resolv::DNS object if a nameserver is given" do
-      subject.resolver(nameserver).should be_kind_of(Resolv::DNS)
+      expect(subject.resolver(nameserver)).to be_kind_of(Resolv::DNS)
     end
 
     it "should return the default resolver otherwise" do
-      subject.resolver.should == Resolv
+      expect(subject.resolver).to eq(Resolv)
     end
   end
 end

data/spec/extensions/string_spec.rb

@@ -7,32 +7,32 @@ describe String do
 
     it "should enumerate over each sub-string within the String" do
       subject.each_substring do |sub_string|
-        should include(sub_string)
+        expect(subject).to include(sub_string)
       end
     end
 
     it "should allow passing the string index back" do
       subject.each_substring do |sub_string,index|
-        subject[index,sub_string.length].should == sub_string
+        expect(subject[index,sub_string.length]).to eq(sub_string)
 
-        should include(sub_string)
+        expect(subject).to include(sub_string)
       end
     end
 
     it "should enumerate over each sub-string of a minimum length" do
       subject.each_substring(2) do |sub_string|
-        sub_string.length.should >= 2
+        expect(sub_string.length).to be >= 2
 
-        should include(sub_string)
+        expect(subject).to include(sub_string)
       end
     end
 
     it "should return an Enumerator when no block is given" do
       substrings = subject.each_substring
       
-      substrings.all? { |sub_string|
+      expect(substrings.all? { |sub_string|
         subject.include?(sub_string)
-      }.should == true
+      }).to be(true)
     end
   end
 
@@ -43,8 +43,8 @@ describe String do
       seen = []
 
       subject.each_unique_substring do |sub_string|
-        should include(sub_string)
-        seen.should_not include(sub_string)
+        expect(subject).to  include(sub_string)
+        expect(seen).to_not include(sub_string)
 
         seen << sub_string
       end
@@ -54,10 +54,10 @@ describe String do
       seen = []
 
       subject.each_unique_substring(2) do |sub_string|
-        sub_string.length.should >= 2
+        expect(sub_string.length).to be >= 2
 
-        should include(sub_string)
-        seen.should_not include(sub_string)
+        expect(subject).to  include(sub_string)
+        expect(seen).to_not include(sub_string)
 
         seen << sub_string
       end
@@ -66,12 +66,13 @@ describe String do
     it "should return an Enumerator when no block is given" do
       seen = subject.each_unique_substring
 
-      seen.all? { |sub_string|
+      expect(seen.all? { |sub_string|
         subject.include?(sub_string)
-      }.should == true
+      }).to be(true)
 
       seen = seen.to_a
-      seen.uniq.should == seen
+
+      expect(seen.uniq).to eq(seen)
     end
   end
 
@@ -81,7 +82,7 @@ describe String do
       two = 'What is puzzling you is the nature of my name'
       common = 'What is puzzling you is the nature of my '
 
-      one.common_prefix(two).should == common
+      expect(one.common_prefix(two)).to eq(common)
     end
 
     it "should return the common prefix between two Strings with no uncommon postfix" do
@@ -89,21 +90,21 @@ describe String do
       two = "12345"
       common = "1234"
 
-      one.common_prefix(two).should == common
+      expect(one.common_prefix(two)).to eq(common)
     end
 
     it "should return an empty String if there is no common prefix" do
       one = 'Tell me people'
       two = 'Whats my name'
 
-      one.common_prefix(two).should == ''
+      expect(one.common_prefix(two)).to eq('')
     end
 
     it "should return an empty String if one of the strings is also empty" do
       one = 'Haha'
       two = ''
 
-      one.common_prefix(two).should == ''
+      expect(one.common_prefix(two)).to eq('')
     end
   end
 
@@ -113,21 +114,21 @@ describe String do
       two = "Can't you guess my name"
       common = 's my name'
 
-      one.common_suffix(two).should == common
+      expect(one.common_suffix(two)).to eq(common)
     end
 
     it "should return an empty String if there is no common postfix" do
       one = 'You got to right up, stand up'
       two = 'stand up for your rights'
 
-      one.common_suffix(two).should == ''
+      expect(one.common_suffix(two)).to eq('')
     end
 
     it "should return an empty String if one of the strings is also empty" do
       one = 'You and I must fight for our rights'
       two = ''
 
-      one.common_suffix(two).should == ''
+      expect(one.common_suffix(two)).to eq('')
     end
   end
 
@@ -137,7 +138,7 @@ describe String do
       two = "Tell me honey whats my name"
       uncommon = 'bab'
 
-      one.uncommon_substring(two).should == uncommon
+      expect(one.uncommon_substring(two)).to eq(uncommon)
     end
 
     it "should find the uncommon substring between two Strings with a common prefix" do
@@ -145,7 +146,7 @@ describe String do
       two = 'You and I must fight to survive'
       uncommon = 'for our rights'
 
-      one.uncommon_substring(two).should == uncommon
+      expect(one.uncommon_substring(two)).to eq(uncommon)
     end
 
     it "should find the uncommon substring between two Strings with a common postfix" do
@@ -153,26 +154,26 @@ describe String do
       two = "Can't you guess my name"
       uncommon = 'Tell me baby what'
 
-      one.uncommon_substring(two).should == uncommon
+      expect(one.uncommon_substring(two)).to eq(uncommon)
     end
   end
 
-  if RUBY_VERSION < '1.9'
+  if RUBY_VERSION < '1.9.'
     describe "#dump" do
       it "should dump printable strings" do
-        "hello".dump.should == '"hello"'
+        expect("hello".dump).to eq('"hello"')
       end
 
       it "should dump strings containing control characters" do
-        "hello\n\b\a".dump.should == '"hello\n\b\a"'
+        expect("hello\n\b\a".dump).to eq('"hello\n\b\a"')
       end
 
       it "should dump strings containing non-printable characters" do
-        "hello\x90\x05\xEF".dump.should == '"hello\x90\x05\xEF"'
+        expect("hello\x90\x05\xEF".dump).to eq('"hello\x90\x05\xEF"')
       end
 
       it "should dump the string when calling the inspect method" do
-        "hello\x90\x05\xEF".inspect.should == '"hello\x90\x05\xEF"'
+        expect("hello\x90\x05\xEF".inspect).to eq('"hello\x90\x05\xEF"')
       end
     end
   end

data/spec/formatting/binary/array_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'ronin/formatting/extensions/binary/array'
+
+describe Array do
+  subject { [0x1234, "hello"] }
+
+  it "should provide Array#pack" do
+    should respond_to(:pack)
+  end
+
+  describe "#pack" do
+    let(:packed) { "\x34\x12hello\0" }
+
+    context "when only given a String" do
+      it "should pack elements using Array#pack codes" do
+        expect(subject.pack('vZ*')).to eq(packed)
+      end
+    end
+
+    context "otherwise" do
+      it "should pack fields using Binary::Template" do
+        expect(subject.pack(:uint16_le, :string)).to eq(packed)
+      end
+    end
+  end
+end

data/spec/formatting/binary/base64_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'ronin/formatting/extensions/binary/base64'
+
+describe Base64 do
+  subject { described_class }
+
+  if RUBY_VERSION < '1.9.'
+    let(:string) { '>' * 64 }
+
+    let(:base64) { "Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+\nPj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pg==\n" }
+    let(:strict_base64) { "Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pg==" }
+    let(:urlsafe_base64) { "Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pg==" }
+
+    describe "strict_encode64" do
+      it "should strictly encode a String" do
+        expect(subject.strict_encode64(string)).to eq(strict_base64)
+      end
+    end
+
+    describe "strict_decode64" do
+      it "should strict decode an encoded Base64 String" do
+        expect(subject.strict_decode64(strict_base64)).to eq(string)
+      end
+
+      it "should raise an ArgumentError for non-strictly encoded Base64" do
+        expect {
+          subject.strict_decode64(base64)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "urlsafe_encode64" do
+      it "should encode URL-safe Base64 Strings" do
+        expect(subject.urlsafe_encode64(string)).to eq(urlsafe_base64)
+      end
+    end
+
+    describe "urlsafe_decode64" do
+      it "should decode URL-safe Base64 String" do
+        expect(subject.urlsafe_decode64(urlsafe_base64)).to eq(string)
+      end
+
+      it "should raise an ArgumentError for non-strictly encoded Base64" do
+        expect {
+          subject.urlsafe_decode64(base64)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/formatting/binary/float_spec.rb

@@ -0,0 +1,36 @@
+# encoding: US-ASCII
+
+require 'spec_helper'
+require 'ronin/formatting/extensions/binary/float'
+
+describe Float do
+  subject { 0.42 }
+
+  it "should provide Float#pack" do
+    should respond_to(:pack)
+  end
+
+  describe "#pack" do
+    let(:packed) { "\xE1z\x14\xAEG\xE1\xDA?" }
+
+    context "when only given a String" do
+      it "should unpack Strings using String#unpack template Strings" do
+        expect(subject.pack('E')).to eq(packed)
+      end
+    end
+
+    context "when given a Binary::Template Float type" do
+      it "should unpack Strings using Binary::Template" do
+        expect(subject.pack(:double_le)).to eq(packed)
+      end
+    end
+
+    context "when given non-Float Binary::Template types" do
+      it "should raise an ArgumentError" do
+        expect {
+          subject.pack(:int)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/formatting/binary/integer_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'ronin/formatting/binary'
+require 'ronin/formatting/extensions/binary/integer'
 
 require 'ostruct'
 
@@ -19,14 +19,14 @@ describe Integer do
   end
 
   it "should alias char to the #chr method" do
-    subject.char.should == subject.chr
+    expect(subject.char).to eq(subject.chr)
   end
 
   describe "#hex_escape" do
     subject { 42 }
 
     it "should hex escape an Integer" do
-      subject.hex_escape.should == "\\x2a"
+      expect(subject.hex_escape).to eq("\\x2a")
     end
   end
 
@@ -44,97 +44,123 @@ describe Integer do
     subject { 0x1337 }
 
     it "should return the bytes in little endian ordering by default" do
-      subject.bytes(4).should == little_endian_long
+      expect(subject.bytes(4)).to eq(little_endian_long)
     end
 
     it "should return the bytes for a char in little endian ordering" do
-      subject.bytes(1, :little).should == little_endian_char
+      expect(subject.bytes(1, :little)).to eq(little_endian_char)
     end
 
     it "should return the bytes for a short in little endian ordering" do
-      subject.bytes(2, :little).should == little_endian_short
+      expect(subject.bytes(2, :little)).to eq(little_endian_short)
     end
 
     it "should return the bytes for a long in little endian ordering" do
-      subject.bytes(4, :little).should == little_endian_long
+      expect(subject.bytes(4, :little)).to eq(little_endian_long)
     end
 
     it "should return the bytes for a quad in little endian ordering" do
-      subject.bytes(8, :little).should == little_endian_quad
+      expect(subject.bytes(8, :little)).to eq(little_endian_quad)
     end
 
     it "should return the bytes for a char in big endian ordering" do
-      subject.bytes(1, :big).should == big_endian_char
+      expect(subject.bytes(1, :big)).to eq(big_endian_char)
     end
 
     it "should return the bytes for a short in big endian ordering" do
-      subject.bytes(2, :big).should == big_endian_short
+      expect(subject.bytes(2, :big)).to eq(big_endian_short)
     end
 
     it "should return the bytes for a long in big endian ordering" do
-      subject.bytes(4, :big).should == big_endian_long
+      expect(subject.bytes(4, :big)).to eq(big_endian_long)
     end
 
     it "should return the bytes for a quad in big endian ordering" do
-      subject.bytes(8, :big).should == big_endian_quad
+      expect(subject.bytes(8, :big)).to eq(big_endian_quad)
     end
   end
 
   describe "#pack" do
-    let(:i386) do
-      OpenStruct.new(:endian => :little, :address_length => 4)
+    subject { 0x1337 }
+
+    let(:packed) { "7\023\000\000" }
+
+    context "when only given a String" do
+      it "should pack Integers using Array#pack codes" do
+        expect(subject.pack('V')).to eq(packed)
+      end
     end
 
-    let(:ppc) do
-      OpenStruct.new(:endian => :big, :address_length => 4)
+    context "when given a Binary::Template Integer type" do
+      it "should pack Integers using Binary::Template" do
+        expect(subject.pack(:uint32_le)).to eq(packed)
+      end
     end
 
-    subject { 0x1337 }
+    context "when given non-Integer Binary::Template types" do
+      it "should raise an ArgumentError" do
+        expect {
+          subject.pack(:float)
+        }.to raise_error(ArgumentError)
+      end
+    end
 
-    let(:i386_packed_int)   { "7\023\000\000" }
-    let(:i386_packed_short) { "7\023" }
-    let(:i386_packed_long)  { "7\023\000\000" }
-    let(:i386_packed_quad)  { "7\023\000\000\000\000\000\000" }
+    context "deprecated" do
+      let(:uint16_le) { "7\023" }
+      let(:uint32_le) { "7\023\000\000" }
+      let(:uint64_le) { "7\023\000\000\000\000\000\000" }
 
-    let(:ppc_packed_int)   { "\000\000\0237" }
-    let(:ppc_packed_short) { "\0237" }
-    let(:ppc_packed_long)  { "\000\000\0237" }
-    let(:ppc_packed_quad)  { "\000\000\000\000\000\000\0237" }
+      let(:uint16_be) { "\0237" }
+      let(:uint32_be) { "\000\000\0237" }
+      let(:uint64_be) { "\000\000\000\000\000\000\0237" }
 
-    it "should pack itself for a little-endian architecture by default" do
-      subject.pack(i386).should == i386_packed_int
-    end
+      let(:i386) do
+        OpenStruct.new(:endian => :little, :address_length => 4)
+      end
 
-    it "should pack itself as a short for a little-endian architecture" do
-      subject.pack(i386,2).should == i386_packed_short
-    end
+      let(:ppc) do
+        OpenStruct.new(:endian => :big, :address_length => 4)
+      end
 
-    it "should pack itself as a long for a little-endian architecture" do
-      subject.pack(i386,4).should == i386_packed_long
-    end
+      it "should pack itself for a little-endian architecture by default" do
+        expect(subject.pack(i386)).to eq(uint32_le)
+      end
 
-    it "should pack itself as a quad for a little-endian architecture" do
-      subject.pack(i386,8).should == i386_packed_quad
-    end
+      it "should pack itself as a short for a little-endian architecture" do
+        expect(subject.pack(i386,2)).to eq(uint16_le)
+      end
 
-    it "should pack itself for a big-endian architecture" do
-      subject.pack(ppc).should == ppc_packed_int
-    end
+      it "should pack itself as a long for a little-endian architecture" do
+        expect(subject.pack(i386,4)).to eq(uint32_le)
+      end
 
-    it "should pack itself as a short for a big-endian architecture" do
-      subject.pack(ppc,2).should == ppc_packed_short
-    end
+      it "should pack itself as a quad for a little-endian architecture" do
+        expect(subject.pack(i386,8)).to eq(uint64_le)
+      end
 
-    it "should pack itself as a long for a big-endian architecture" do
-      subject.pack(ppc,4).should == ppc_packed_long
-    end
+      it "should pack itself for a big-endian architecture" do
+        expect(subject.pack(ppc)).to eq(uint32_be)
+      end
+
+      it "should pack itself as a short for a big-endian architecture" do
+        expect(subject.pack(ppc,2)).to eq(uint16_be)
+      end
+
+      it "should pack itself as a long for a big-endian architecture" do
+        expect(subject.pack(ppc,4)).to eq(uint32_be)
+      end
 
-    it "should pack itself as a quad for a big-endian architecture" do
-      subject.pack(ppc,8).should == ppc_packed_quad
+      it "should pack itself as a quad for a big-endian architecture" do
+        expect(subject.pack(ppc,8)).to eq(uint64_be)
+      end
     end
 
-    it "should accept Array#pack template strings" do
-      subject.pack('L').should == i386_packed_long
+    context "when given more than 1 or 2 arguments" do
+      it "should raise an ArgumentError" do
+        expect {
+          subject.pack(1,2,3)
+        }.to raise_error(ArgumentError)
+      end
     end
   end
 end