ronin-support 0.5.1 → 0.5.2

data/spec/fuzzing/extensions/string_spec.rb

@@ -3,19 +3,19 @@ require 'ronin/fuzzing/extensions/string'
 
 describe String do
   it "should provide String.generate" do
-    described_class.should respond_to(:generate)
+    expect(described_class).to respond_to(:generate)
   end
 
   it "should provide String#repeating" do
-    subject.should respond_to(:repeating)
+    expect(subject).to respond_to(:repeating)
   end
 
   it "should provide String#fuzz" do
-    subject.should respond_to(:fuzz)
+    expect(subject).to respond_to(:fuzz)
   end
 
   it "should provide String#mutate" do
-    subject.should respond_to(:mutate)
+    expect(subject).to respond_to(:mutate)
   end
 
   describe "generate" do
@@ -24,7 +24,7 @@ describe String do
     it "should generate Strings from a template" do
       strings = subject.generate([:numeric, 2]).to_a
 
-      strings.grep(/^[0-9]{2}$/).should == strings
+      expect(strings.grep(/^[0-9]{2}$/)).to eq(strings)
     end
   end
 
@@ -35,7 +35,7 @@ describe String do
       let(:n) { 100 }
 
       it "should multiply the String by n" do
-        subject.repeating(n).should == (subject * n)
+        expect(subject.repeating(n)).to eq(subject * n)
       end
     end
 
@@ -45,7 +45,7 @@ describe String do
       it "should repeat the String by each length" do
         strings = subject.repeating(n).to_a
 
-        strings.should == n.map { |length| subject * length }
+        expect(strings).to eq(n.map { |length| subject * length })
       end
     end
   end
@@ -56,14 +56,14 @@ describe String do
     it "should apply each fuzzing rule individually" do
       strings = subject.fuzz(/o/ => ['O', '0'], /a/ => ['A', '@']).to_a
       
-      strings.should =~ [
+      expect(strings).to match_array([
         "fOo bar",
         "f0o bar",
         "foO bar",
         "fo0 bar",
         "foo bAr",
         "foo b@r"
-      ]
+      ])
     end
   end
 
@@ -73,7 +73,7 @@ describe String do
     it "should apply every combination of mutation rules" do
       strings = subject.mutate(/o/ => ['0'], /a/ => ['@']).to_a
 
-      strings.should =~ [
+      expect(strings).to match_array([
         "f0o bar",
         "fo0 bar",
         "f00 bar",
@@ -81,7 +81,7 @@ describe String do
         "f0o b@r",
         "fo0 b@r",
         "f00 b@r"
-      ]
+      ])
     end
   end
 end

data/spec/fuzzing/fuzzer_spec.rb

@@ -13,14 +13,14 @@ describe Fuzzing::Fuzzer do
       it "should accept Regexps" do
         fuzzer = subject.new(/foo/ => substitutions)
 
-        fuzzer.rules.should have_key(/foo/)
+        expect(fuzzer.rules).to 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/)
+          expect(subject.rules).to have_key(/foo/)
         end
       end
 
@@ -28,15 +28,15 @@ describe Fuzzing::Fuzzer do
         subject { described_class.new(:word => substitutions) }
 
         it "should lookup the Regexp constant" do
-          subject.rules.should have_key(Regexp::WORD)
+          expect(subject.rules).to have_key(Regexp::WORD)
         end
       end
 
       context "otherwise" do
         it "should raise a TypeError" do
-          lambda {
+          expect {
             subject.new(Object.new => substitutions)
-          }.should raise_error(TypeError)
+          }.to raise_error(TypeError)
         end
       end
     end
@@ -47,22 +47,22 @@ describe Fuzzing::Fuzzer do
       it "should accept Enumerable values" do
         fuzzer = subject.new(pattern => ['bar'])
 
-        fuzzer.rules[pattern].should == ['bar']
+        expect(fuzzer.rules[pattern]).to eq(['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)
+          expect(subject.rules[pattern]).to be_kind_of(Enumerable)
         end
       end
 
       context "otherwise" do
         it "should raise a TypeError" do
-          lambda {
+          expect {
             subject.new(pattern => Object.new)
-          }.should raise_error(TypeError)
+          }.to raise_error(TypeError)
         end
       end
     end
@@ -74,24 +74,24 @@ describe Fuzzing::Fuzzer do
     subject { described_class.new(/o/ => ['O', '0'], /a/ => ['A', '@']) }
 
     it "should apply each fuzzing rule individually" do
-      subject.each(string).to_a.should =~ [
+      expect(subject.each(string).to_a).to match_array([
         "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 =~ [
+        expect(subject.each(string).to_a).to match_array([
           "f0o bar",
           "fo0 bar"
-        ]
+        ])
       end
     end
 
@@ -99,10 +99,10 @@ describe Fuzzing::Fuzzer 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 =~ [
+        expect(subject.each(string).to_a).to match_array([
           "fOo bar",
           "foO bar"
-        ]
+        ])
       end
     end
   end

data/spec/fuzzing/fuzzing_spec.rb

@@ -6,19 +6,19 @@ describe Fuzzing do
     let(:method) { :bad_strings }
 
     it "should return Enumerators for fuzzing methods" do
-      subject[method].should be_kind_of(Enumerable)
+      expect(subject[method]).to be_kind_of(Enumerable)
     end
 
     it "should raise NoMethodError for unknown methods" do
-      lambda {
+      expect {
         subject[:foo]
-      }.should raise_error(NoMethodError)
+      }.to raise_error(NoMethodError)
     end
 
     it "should not allow accessing inherited methods" do
-      lambda {
+      expect {
         subject[:instance_eval]
-      }.should raise_error(NoMethodError)
+      }.to raise_error(NoMethodError)
     end
   end
 end

data/spec/fuzzing/mutator_spec.rb

@@ -13,14 +13,14 @@ describe Fuzzing::Mutator do
       it "should accept Regexps" do
         fuzzer = subject.new(/foo/ => substitutions)
 
-        fuzzer.rules.should have_key(/foo/)
+        expect(fuzzer.rules).to 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/)
+          expect(subject.rules).to have_key(/foo/)
         end
       end
 
@@ -28,15 +28,15 @@ describe Fuzzing::Mutator do
         subject { described_class.new(:word => substitutions) }
 
         it "should lookup the Regexp constant" do
-          subject.rules.should have_key(Regexp::WORD)
+          expect(subject.rules).to have_key(Regexp::WORD)
         end
       end
 
       context "otherwise" do
         it "should raise a TypeError" do
-          lambda {
+          expect {
             subject.new(Object.new => substitutions)
-          }.should raise_error(TypeError)
+          }.to raise_error(TypeError)
         end
       end
     end
@@ -47,22 +47,22 @@ describe Fuzzing::Mutator do
       it "should accept Enumerable values" do
         fuzzer = subject.new(pattern => ['bar'])
 
-        fuzzer.rules[pattern].should == ['bar']
+        expect(fuzzer.rules[pattern]).to eq(['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)
+          expect(subject.rules[pattern]).to be_kind_of(Enumerable)
         end
       end
 
       context "otherwise" do
         it "should raise a TypeError" do
-          lambda {
+          expect {
             subject.new(pattern => Object.new)
-          }.should raise_error(TypeError)
+          }.to raise_error(TypeError)
         end
       end
     end
@@ -74,7 +74,7 @@ describe Fuzzing::Mutator do
     subject { described_class.new(/o/ => ['0'], /a/ => ['@']) }
 
     it "should apply every combination of mutation rules" do
-      subject.each(string).to_a.should =~ [
+      expect(subject.each(string).to_a).to match_array([
         "f0o bar",
         "fo0 bar",
         "f00 bar",
@@ -82,18 +82,18 @@ describe Fuzzing::Mutator do
         "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 =~ [
+        expect(subject.each(string).to_a).to match_array([
           "f0o bar",
           "fo0 bar",
           "f00 bar"
-        ]
+        ])
       end
     end
 
@@ -101,11 +101,11 @@ describe Fuzzing::Mutator 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 =~ [
+        expect(subject.each(string).to_a).to match_array([
           "fOo bar",
           "foO bar",
           "fOO bar"
-        ]
+        ])
       end
     end
   end

data/spec/fuzzing/repeater_spec.rb

@@ -9,15 +9,15 @@ describe Fuzzing::Repeater do
       it "should coerce lengths to an Enumerable" do
         repeator = subject.new(10)
 
-        repeator.lengths.should be_kind_of(Enumerable)
+        expect(repeator.lengths).to be_kind_of(Enumerable)
       end
     end
 
     context "when lengths is not Enumerable or an Integer" do
       it "should raise a TypeError" do
-        lambda {
+        expect {
           subject.new(Object.new)
-        }.should raise_error(TypeError)
+        }.to raise_error(TypeError)
       end
     end
   end
@@ -33,7 +33,7 @@ describe Fuzzing::Repeater do
       it "should yield one repeated value" do
         values = subject.each(repeatable).to_a
         
-        values.should == [repeatable * length]
+        expect(values).to eq([repeatable * length])
       end
     end
 
@@ -43,14 +43,14 @@ describe Fuzzing::Repeater do
       subject { described_class.new(lengths) }
 
       it "should yield repeated values for each length" do
-        values = subject.each(repeatable).to_a.should
+        values = subject.each(repeatable).to_a
 
-        values.should == [
+        expect(values).to eq([
           repeatable * 1,
           repeatable * 2,
           repeatable * 3,
           repeatable * 4
-        ]
+        ])
       end
     end
   end

data/spec/fuzzing/template_spec.rb

@@ -7,48 +7,48 @@ describe Fuzzing::Template do
   it "should generate Strings from CharSets" do
     strings = subject.new([:lowercase_hexadecimal, :numeric]).to_a
 
-    strings.grep(/^[0-9a-f][0-9]$/).should == strings
+    expect(strings.grep(/^[0-9a-f][0-9]$/)).to eq(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
+    expect(strings.grep(/^[0-9]{2}$/)).to eq(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
+    expect(strings.grep(/^[0-9]{1,2}$/)).to eq(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
+    expect(strings.grep(/^[abc]{2}$/)).to eq(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
+    expect(strings.grep(/^foo[abc]{2}$/)).to eq(strings)
   end
 
   it "should raise a TypeError for non String, Symbol, Enumerable CharSets" do
-    lambda {
+    expect {
       subject.new([[Object.new, 2]]).to_a
-    }.should raise_error(TypeError)
+    }.to raise_error(TypeError)
   end
 
   it "should raise an ArgumentError for unknown CharSets" do
-    lambda {
+    expect {
       subject.new([[:foo_bar, 2]]).to_a
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   it "should raise a TypeError for non Integer,Array,Range lengths" do
-    lambda {
+    expect {
       subject.new([[:numeric, 'foo']]).to_a
-    }.should raise_error(TypeError)
+    }.to raise_error(TypeError)
   end
 end

data/spec/mixin_spec.rb

@@ -20,34 +20,32 @@ describe Mixin do
   end
 
   context "when included" do
-    before(:all) do
-      @base = Class.new
-      @base.send :include, subject
+    let(:klass) do
+      Class.new.tap { |klass| klass.send :include, subject }
     end
 
     it "should include the mixed in modules" do
-      @base.should include(Mixins::Test1)
-      @base.should include(Mixins::Test2)
+      expect(klass).to include(Mixins::Test1)
+      expect(klass).to include(Mixins::Test2)
     end
 
     it "should evaluate the mixin block" do
-      @base.instance_variable_get("@var").should == 1
+      expect(klass.instance_variable_get("@var")).to eq(1)
     end
   end
 
   context "when extended" do
-    before(:all) do
-      @base = Object.new
-      @base.send :extend, subject
+    let(:object) do
+      Object.new.tap { |obj| obj.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)
+      expect(object).to be_kind_of(Mixins::Test1)
+      expect(object).to be_kind_of(Mixins::Test2)
     end
 
     it "should evaluate the mixin block" do
-      @base.instance_variable_get("@var").should == 1
+      expect(object.instance_variable_get("@var")).to eq(1)
     end
   end
 end