dawnscanner 1.6.1 → 1.6.2

data/spec/lib/dawn/codesake_padrino_engine_disabled.rb

@@ -8,33 +8,33 @@ describe "The Dawn engine for padrino applications" do
     
 
   it "has a proper name" do
-    @engine.name.should   ==    "padrino"
+    expect(@engine.name).to   eq("padrino")
   end
 
   it "has a valid target" do
-    @engine.target.should ==   "./spec/support/hello_world_padrino"
-    @engine.target_is_dir?.should  be_true
+    expect(@engine.target).to eq("./spec/support/hello_world_padrino")
+    expect(@engine.target_is_dir?).to  be_truthy
   end
 
   it "detects the applications declared in config/apps.rb" do
-    @engine.should  respond_to(:detect_apps)
-    @engine.apps.should_not     be_nil
-    @engine.apps.count.should   == 3
+    expect(@engine).to  respond_to(:detect_apps)
+    expect(@engine.apps).not_to     be_nil
+    expect(@engine.apps.count).to   eq(3)
   end
 
   it "creates a valid pool of Sinatra engines" do
-    @engine.apps[0].mount_point.should == "/"
-    @engine.apps[1].mount_point.should == "/log"
-    @engine.apps[2].mount_point.should == "/dispatcher"
+    expect(@engine.apps[0].mount_point).to eq("/")
+    expect(@engine.apps[1].mount_point).to eq("/log")
+    expect(@engine.apps[2].mount_point).to eq("/dispatcher")
   end
 
 
   it "has a good Gemfile.lock" do
-    @engine.has_gemfile_lock?.should   be_true
+    expect(@engine.has_gemfile_lock?).to   be_truthy
   end
 
   it "detects padrino v0.11.2" do
-    @engine.mvc_version.should   == "0.11.2"
+    expect(@engine.mvc_version).to   eq("0.11.2")
   end
 
   

data/spec/lib/dawn/codesake_rails_engine_disabled.rb

@@ -5,8 +5,8 @@ describe "The Dawn engine for rails applications" do
 
   it "detects the version used in the hello_world_3.1.0 application" do
     @engine.set_target("./spec/support/hello_world_3.1.0")
-    @engine.ruby_version[:version].should == RUBY_VERSION
-    @engine.ruby_version[:patchlevel].should == "p#{RUBY_PATCHLEVEL}"
+    expect(@engine.ruby_version[:version]).to eq(RUBY_VERSION)
+    expect(@engine.ruby_version[:patchlevel]).to eq("p#{RUBY_PATCHLEVEL}")
   end
 
 end

data/spec/lib/dawn/codesake_sinatra_engine_disabled.rb

@@ -4,124 +4,124 @@ describe "The Dawn engine for sinatra applications" do
   before(:all) {@engine= Dawn::Sinatra.new('./spec/support/sinatra-safe')}
 
   it "has a proper name" do
-    @engine.name.should   ==    "sinatra"
+    expect(@engine.name).to   eq("sinatra")
   end
 
   it "detects the default application name" do
-    @engine.appname.should == "application.rb"
+    expect(@engine.appname).to eq("application.rb")
   end
   it "has a valid target" do
-    @engine.target.should ==   "./spec/support/sinatra-safe"
-    @engine.target_is_dir?.should  be_true
+    expect(@engine.target).to eq("./spec/support/sinatra-safe")
+    expect(@engine.target_is_dir?).to  be_truthy
   end
 
   it "has a good Gemfile.lock" do
-    @engine.has_gemfile_lock?.should   be_true
+    expect(@engine.has_gemfile_lock?).to   be_truthy
   end
 
   it "detects a sinatra 1.4.4" do
-    @engine.mvc_version.should   == "1.4.4"
+    expect(@engine.mvc_version).to   eq("1.4.4")
   end
 
   it "detects 2 views" do
-    @engine.views.should == [{:filename=>"./spec/support/sinatra-safe/views/layout.haml", :language=>:haml}, {:filename=>"./spec/support/sinatra-safe/views/root.haml", :language=>:haml}]
+    expect(@engine.views).to eq([{:filename=>"./spec/support/sinatra-safe/views/layout.haml", :language=>:haml}, {:filename=>"./spec/support/sinatra-safe/views/root.haml", :language=>:haml}])
   end
   it "detects views are written using HAML" do
-    @engine.views[0][:language].should == :haml
-    @engine.views[1][:language].should == :haml
+    expect(@engine.views[0][:language]).to eq(:haml)
+    expect(@engine.views[1][:language]).to eq(:haml)
   end
 
   it "has some check in the knowledge base" do
-    @engine.checks.should_not be_nil 
-    @engine.checks.should_not be_empty
+    expect(@engine.checks).not_to be_nil 
+    expect(@engine.checks).not_to be_empty
   end
   it "has check for CVE-2013-1800" do
-    Dawn::KnowledgeBase.find(@engine.checks, "CVE-2013-1800").should_not  be_nil
+    expect(Dawn::KnowledgeBase.find(@engine.checks, "CVE-2013-1800")).not_to  be_nil
   end
 
   it "applies all checks" do
-    @engine.apply_all.should  be_true
+    expect(@engine.apply_all).to  be_truthy
   end
   it "applies check for CVE-2013-1800" do
-    @engine.apply("CVE-2013-1800").should   be_true
+    expect(@engine.apply("CVE-2013-1800")).to   be_truthy
   end
   
   it "applies check for \"Not revised code\"" do
-    @engine.apply("Not revised code").should  be_true
+    expect(@engine.apply("Not revised code")).to  be_truthy
   end 
 
   describe "applied to sinatra-safe application" do
     it "reports it's not vulnerable to CVE-2013-1800" do
-      @engine.is_vulnerable_to?("CVE-2013-1800").should be_false
+      expect(@engine.is_vulnerable_to?("CVE-2013-1800")).to be_falsey
     end
 
     it "reports it's not vulnerable to \"Not revised code\"" do
-      @engine.is_vulnerable_to?("Not revised code").should  be_false
+      expect(@engine.is_vulnerable_to?("Not revised code")).to  be_falsey
     end
 
     it "reports it has no vulnerabilities" do
       puts @engine.vulnerabilities
-      @engine.vulnerabilities.should  be_empty
+      expect(@engine.vulnerabilities).to  be_empty
     end
   end  
 
   describe "applied do the sinatra-vulnerable application" do
     before (:all) {@engine= Dawn::Sinatra.new('./spec/support/sinatra-vulnerable')}
     it "has a valid target" do
-      @engine.target.should ==   "./spec/support/sinatra-vulnerable"
-      @engine.target_is_dir?.should  be_true
+      expect(@engine.target).to eq("./spec/support/sinatra-vulnerable")
+      expect(@engine.target_is_dir?).to  be_truthy
     end
 
     it "detects running ruby as the one to be checked against" do
-      @engine.ruby_version[:version].should == RUBY_VERSION
+      expect(@engine.ruby_version[:version]).to eq(RUBY_VERSION)
     end
 
     it "reports it's vulnerable to CVE-2013-1800" do
-      @engine.is_vulnerable_to?("CVE-2013-1800").should be_true
+      expect(@engine.is_vulnerable_to?("CVE-2013-1800")).to be_truthy
     end
 
     it "reports it's vulnerable to \"Not revised code\"" do
-      @engine.is_vulnerable_to?("Not revised code").should  be_true
+      expect(@engine.is_vulnerable_to?("Not revised code")).to  be_truthy
     end
 
     it "reports it has vulnerabilities" do
-      @engine.vulnerabilities.should_not  be_empty
+      expect(@engine.vulnerabilities).not_to  be_empty
     end
 
     it "applies automagically all the tests if no test has been applied" do
       e2 =  Dawn::Sinatra.new('./spec/support/sinatra-vulnerable')
-      e2.vulnerabilities.should_not be_empty
+      expect(e2.vulnerabilities).not_to be_empty
     end
 
     context "when scanning for XSS" do
       it "detects 3 views" do
-        @engine.views.should == [
+        expect(@engine.views).to eq([
           {:filename=>"./spec/support/sinatra-vulnerable/views/layout.haml", :language=>:haml}, 
           {:filename=>"./spec/support/sinatra-vulnerable/views/root.haml", :language=>:haml}, 
           {:filename=>"./spec/support/sinatra-vulnerable/views/xss.haml", :language=>:haml}
-        ]
+        ])
       end
       it "detects views are written using HAML" do
-        @engine.views[0][:language].should == :haml
-        @engine.views[1][:language].should == :haml
-        @engine.views[2][:language].should == :haml
+        expect(@engine.views[0][:language]).to eq(:haml)
+        expect(@engine.views[1][:language]).to eq(:haml)
+        expect(@engine.views[2][:language]).to eq(:haml)
       end
 
       it "detects a sink on application.rb" do
         sink = @engine.detect_sinks("application.rb")
-        sink.should == [ 
+        expect(sink).to eq([ 
           {:sink_name=>"@xss_param", :sink_kind=>:params, :sink_line=>26, :sink_source=>"name", :sink_file=>"application.rb", :sink_evidence=>"  @xss_param = params['name']"},
           {:sink_name=>"@my_arr", :sink_kind=>:params, :sink_line=>27, :sink_source=>"second", :sink_file=>"application.rb", :sink_evidence=>"  @my_arr[0] = params['second']"}
-        ]
+        ])
       end
 
       it "detects reflected ones in HAML views" do
         reflected_xss= @engine.detect_reflected_xss
-        @engine.reflected_xss.should_not be_nil
-        @engine.reflected_xss.should_not be_empty 
-        @engine.reflected_xss.should == [
+        expect(@engine.reflected_xss).not_to be_nil
+        expect(@engine.reflected_xss).not_to be_empty 
+        expect(@engine.reflected_xss).to eq([
           {:sink_name=>"@xss_param", :sink_kind=>:params, :sink_line=>26, :sink_source=>"name", :sink_file=>"application.rb", :sink_evidence=>"  @xss_param = params['name']", :sink_view=>"./spec/support/sinatra-vulnerable/views/xss.haml"}
-        ]
+        ])
       end
     end
   end

data/spec/lib/kb/codesake_cve_2013_0175_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe "CVE-2013-0175 security check" do
   let (:check) {Dawn::Kb::CVE_2013_0175.new}
   it "knows its name" do
-    check.name.should == "CVE-2013-0175"
+    expect(check.name).to eq("CVE-2013-0175")
   end
   it "has a 7.5 cvss score" do
     check.cvss_score == 7.5
@@ -11,24 +11,24 @@ describe "CVE-2013-0175 security check" do
 
   it "fires when multi_xml vulnerable gem it has been found" do
     check.dependencies = [{:name=>"multi_xml", :version=>"0.5.2"}]
-    check.vuln?.should == true
+    expect(check.vuln?).to eq(true)
   end
   it "fires when Grape vulnerable gem it has been found" do
     check.dependencies = [{:name=>"grape", :version=>"0.2.5"}]
-    check.vuln?.should == true
+    expect(check.vuln?).to eq(true)
   end
   it "fires when multi_xml gem is not vulnerable but Grape is" do
     check.dependencies = [{:name=>"grape", :version=>"0.2.5"}, {:name=>"multi_xml", :version=>"0.5.3"}]
-    check.vuln?.should == true
+    expect(check.vuln?).to eq(true)
   end
   it "fires when multi_xml gem is vulnerable but Grape is not" do
     check.dependencies = [{:name=>"grape", :version=>"0.2.6"}, {:name=>"multi_xml", :version=>"0.5.2"}]
-    check.vuln?.should == true
+    expect(check.vuln?).to eq(true)
   end
 
   it "doesn't fire when no vulnerabilities were found" do
     check.dependencies = [{:name=>"grape", :version=>"0.2.6"}, {:name=>"multi_xml", :version=>"0.5.3"}]
-    check.vuln?.should == false
+    expect(check.vuln?).to eq(false)
   end
 
 

data/spec/lib/kb/codesake_cve_2013_4457_spec.rb

@@ -7,33 +7,33 @@ describe "The CVE-2013-4457 vulnerability" do
   end
   it "is detected if vulnerable version of cocaine rubygem is detected" do
     @check.dependencies=[{:name=>"cocaine", :version=>'0.4.0'}]
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "is detected if vulnerable version of cocaine rubygem is detected" do
     @check.dependencies=[{:name=>"cocaine", :version=>'0.4.1'}]
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "is detected if vulnerable version of cocaine rubygem is detected" do
     @check.dependencies=[{:name=>"cocaine", :version=>'0.4.2'}]
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "is detected if vulnerable version of cocaine rubygem is detected" do
     @check.dependencies=[{:name=>"cocaine", :version=>'0.5.0'}]
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "is detected if vulnerable version of cocaine rubygem is detected" do
     @check.dependencies=[{:name=>"cocaine", :version=>'0.5.1'}]
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "is detected if vulnerable version of cocaine rubygem is detected" do
     @check.dependencies=[{:name=>"cocaine", :version=>'0.5.2'}]
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
 
   it "is skipped if non vulnerable version of cocaine rubygem is detected" do
     @check.dependencies=[{:name=>"cocaine", :version=>'0.3.2'}]
     # @check.debug = true
-    @check.vuln?.should   == false
+    expect(@check.vuln?).to   eq(false)
   end
 
 

data/spec/lib/kb/codesake_dependency_version_check_spec.rb

@@ -25,50 +25,50 @@ describe "The security check for gem dependency should" do
   # let (:check) {Mockup.new}
 
   it "gives an unkown priority value" do
-    @check.priority.should == "unknown"
+    expect(@check.priority).to eq("unknown")
   end
 
   it "gives the assigned priority value" do
     @check.priority = :critical
-    @check.priority.should == "critical"
+    expect(@check.priority).to eq("critical")
   end
   it "gives an unknown severity since no CVSS is provided and no severity is given" do
-    @check.severity.should  == "unknown"
+    expect(@check.severity).to  eq("unknown")
   end
 
   it "gives the severity level provided. No CVSS is here" do
     @check.severity = :critical
-    @check.severity.should  == "critical"
+    expect(@check.severity).to  eq("critical")
   end
 
   it "fires if vulnerable 0.2.9 version is detected" do
     @check.dependencies = [{:name=>"this_gem", :version=>'0.2.9'}]
-    @check.vuln?.should    == true
+    expect(@check.vuln?).to    eq(true)
   end
   it "doesn't fire if not vulnerable 0.4.0 version is found" do
     @check.dependencies = [{:name=>"this_gem", :version=>'0.4.0'}]
-    @check.vuln?.should    == false
+    expect(@check.vuln?).to    eq(false)
   end
 
   it "fires if vulnerable 1.3.2 version is found" do
     @check.dependencies = [{:name=>"this_gem", :version=>'1.3.2'}]
-    @check.vuln?.should    == true
+    expect(@check.vuln?).to    eq(true)
   end
 
   it "doesn't fire if not vulnerable 1.4.2 version is found" do
     @check.dependencies = [{:name=>"this_gem", :version=>'1.4.2'}]
-    @check.vuln?.should    == false
+    expect(@check.vuln?).to    eq(false)
   end
 
   it "doesn't fires when a non vulnerable version is found and there is a fixed version with higher minor release but I asked to honor the minor version (useful with rails gem)" do
     @check.dependencies = [{:name=>"this_gem", :version=>'2.3.3'}]
     @check.save_minor = true
-    @check.vuln?.should    == false
+    expect(@check.vuln?).to    eq(false)
   end
   it "fires when a vulnerable version (2.3.2) is found even if I asked to save minors..." do
     @check.dependencies = [{:name=>"this_gem", :version=>'2.3.2'}]
     @check.save_minor = true
-    @check.vuln?.should    == true
+    expect(@check.vuln?).to    eq(true)
 
   end
 

data/spec/lib/kb/codesake_deprecation_check_spec.rb

@@ -11,46 +11,46 @@ describe "The deprecation check for Ruby and MVC" do
   ############################################################################
   it "should mark a random 1.1.x ruby version as deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"1.1.#{give_a_number}"}
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "should mark a random 1.2.x ruby version as deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"1.2.#{give_a_number}"}
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "should mark a random 1.3.x ruby version as deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"1.3.#{give_a_number}"}
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "should mark a random 1.4.x ruby version as deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"1.4.#{give_a_number}"}
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "should mark a random 1.5.x ruby version as deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"1.5.#{give_a_number}"}
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "should mark a random 1.6.x ruby version as deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"1.6.#{give_a_number}"}
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "should mark a random 1.7.x ruby version as deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"1.7.#{give_a_number}"}
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "should mark ruby version 1.8.7 as deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"1.8.7"}
-    @check.vuln?.should   == true
+    expect(@check.vuln?).to   eq(true)
   end
   it "should mark a random 1.9.x ruby version as non deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"1.9.#{give_a_number}"}
-    @check.vuln?.should   == false
+    expect(@check.vuln?).to   eq(false)
   end
   it "should mark ruby version 2.0.0 as non deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"2.0.0"}
-    @check.vuln?.should   == false
+    expect(@check.vuln?).to   eq(false)
   end
   it "should mark ruby version 2.1.0 as non deprecated" do
     @check.detected = {:gem=>"ruby", :version=>"2.1.0"}
-    @check.vuln?.should   == false
+    expect(@check.vuln?).to   eq(false)
   end
 end

data/spec/lib/kb/codesake_ruby_version_check_spec.rb

@@ -21,20 +21,20 @@ describe "The security check for Ruby interpreter version" do
 
   it "fires if ruby version is vulnerable" do
     check.detected_ruby = {:version=>"1.9.2", :patchlevel=>"p10000"}
-    check.vuln?.should    == true
+    expect(check.vuln?).to    eq(true)
   end
   it "doesn't fire if ruby version is not vulnerable and patchlevel is not vulnerable" do
     check.detected_ruby = {:version=>"1.9.4", :patchlevel=>"p10000"}
-    check.vuln?.should    == false
+    expect(check.vuln?).to    eq(false)
   end
 
   it "doesn't fire if ruby version is vulnerable and patchlevel is not vulnerable" do
     check.detected_ruby = {:version=>"1.9.3", :patchlevel=>"p10000"}
-    check.vuln?.should    == false
+    expect(check.vuln?).to    eq(false)
   end
 
   it "fires if ruby version is vulnerable and patchlevel is vulnerable" do
     check.detected_ruby = {:version=>"1.9.3", :patchlevel=>"p391"}
-    check.vuln?.should    == true
+    expect(check.vuln?).to    eq(true)
   end
 end

data/spec/lib/kb/codesake_version_check_spec.rb

@@ -13,153 +13,153 @@ describe "The version check should" do
   context "without some beta versions to handle" do
 
     it "reports when a version is vulnerable" do
-      @check.is_vulnerable_version?('2.3.0', '2.2.9').should == true
+      expect(@check.is_vulnerable_version?('2.3.0', '2.2.9')).to eq(true)
     end
 
     it "reports when a version is not vulnerable (equals)" do
-      @check.is_vulnerable_version?('2.3.0', '2.3.0').should == false
+      expect(@check.is_vulnerable_version?('2.3.0', '2.3.0')).to eq(false)
     end
 
     it "reports when a version is not vulnerable" do
-      @check.is_vulnerable_version?('2.3.0', '2.3.1').should == false
+      expect(@check.is_vulnerable_version?('2.3.0', '2.3.1')).to eq(false)
     end
     it "reports when a version is not vulnerable" do
-      @check.is_vulnerable_version?('2.3.0', '2.4.1').should == false
+      expect(@check.is_vulnerable_version?('2.3.0', '2.4.1')).to eq(false)
     end
     it "reports when a version is not vulnerable" do
-      @check.is_vulnerable_version?('2.3.0', '4.4.1').should == false
+      expect(@check.is_vulnerable_version?('2.3.0', '4.4.1')).to eq(false)
     end
     it "reports when a version is not vulnerable" do
-      @check.is_vulnerable_version?('2.3.0', '4.1.1').should == false
+      expect(@check.is_vulnerable_version?('2.3.0', '4.1.1')).to eq(false)
     end
 
     # check for x character support
 
     it "reports when a version is not vulnerable" do
-      @check.is_vulnerable_version?('2.x', '4.1.1').should == false
+      expect(@check.is_vulnerable_version?('2.x', '4.1.1')).to eq(false)
     end
     it "reports when a version is not vulnerable" do
-      @check.is_vulnerable_version?('2.x', '4.4.1').should == false
+      expect(@check.is_vulnerable_version?('2.x', '4.4.1')).to eq(false)
     end
     it "reports when a version is not vulnerable" do
-      @check.is_vulnerable_version?('2.x', '4.4.1').should == false
+      expect(@check.is_vulnerable_version?('2.x', '4.4.1')).to eq(false)
     end
     it "reports when a version is vulnerable" do
-      @check.is_vulnerable_version?('2.x', '1.4.1').should == true
+      expect(@check.is_vulnerable_version?('2.x', '1.4.1')).to eq(true)
     end
 
 
   end
   context "with some beta versions to handle" do
     it "reports when a beta version is vulnerable" do
-      @check.is_vulnerable_version?('2.3.0.beta3', '2.3.0.beta1').should == true
+      expect(@check.is_vulnerable_version?('2.3.0.beta3', '2.3.0.beta1')).to eq(true)
     end
     it "reports when a beta version is not vulnerable" do
-      @check.is_vulnerable_version?('2.3.0.beta3', '2.3.0.beta5').should == false
+      expect(@check.is_vulnerable_version?('2.3.0.beta3', '2.3.0.beta5')).to eq(false)
     end
     it "reports when a beta version is not vulnerable (equals)" do
-      @check.is_vulnerable_version?('2.3.0.beta5', '2.3.0.beta5').should == false
+      expect(@check.is_vulnerable_version?('2.3.0.beta5', '2.3.0.beta5')).to eq(false)
     end
     it "reports a vulnerability when a stable version is safe and beta is detected" do
-      @check.is_vulnerable_version?('2.3.0', '2.3.0.beta9').should == true
+      expect(@check.is_vulnerable_version?('2.3.0', '2.3.0.beta9')).to eq(true)
     end
     it "reports a safe condition when a beta version is safe and the stable version is detected" do
-      @check.is_vulnerable_version?('2.3.0.beta9', '2.3.0').should == false
+      expect(@check.is_vulnerable_version?('2.3.0.beta9', '2.3.0')).to eq(false)
     end
     it "reports a vulnerability when a previous beta version is detected" do
-      @check.is_vulnerable_version?('2.3.0', '2.2.10.beta2').should == true
+      expect(@check.is_vulnerable_version?('2.3.0', '2.2.10.beta2')).to eq(true)
     end
     it "reports a safe condition when a beta version is detected but the safe version was released earlier (same major, same minor)" do
-      @check.is_vulnerable_version?('2.2.0', '2.2.10.beta2').should == false
+      expect(@check.is_vulnerable_version?('2.2.0', '2.2.10.beta2')).to eq(false)
     end
     it "reports a safe condition when a beta version is detected but the safe version was released earlier (same major)" do
-      @check.is_vulnerable_version?('2.2.0', '2.4.10.beta2').should == false
+      expect(@check.is_vulnerable_version?('2.2.0', '2.4.10.beta2')).to eq(false)
     end
     it "reports a safe condition when a beta version is detected but the safe version was released earlier" do
-      @check.is_vulnerable_version?('2.2.0', '3.4.10.beta2').should == false
+      expect(@check.is_vulnerable_version?('2.2.0', '3.4.10.beta2')).to eq(false)
     end
   end
 
   context "with some rc versions to handle" do
     it "reports when a rc version is vulnerable" do
-      @check.is_vulnerable_version?('2.3.0.rc3', '2.3.0.rc1').should == true
+      expect(@check.is_vulnerable_version?('2.3.0.rc3', '2.3.0.rc1')).to eq(true)
     end
     it "reports when a rc version is not vulnerable" do
-      @check.is_vulnerable_version?('2.3.0.rc3', '2.3.0.rc5').should == false
+      expect(@check.is_vulnerable_version?('2.3.0.rc3', '2.3.0.rc5')).to eq(false)
     end
     it "reports when a rc version is not vulnerable (equals)" do
-      @check.is_vulnerable_version?('2.3.0.rc5', '2.3.0.rc5').should == false
+      expect(@check.is_vulnerable_version?('2.3.0.rc5', '2.3.0.rc5')).to eq(false)
     end
     it "reports a vulnerability when a stable version is safe and rc is detected" do
-      @check.is_vulnerable_version?('2.3.0', '2.3.0.rc9').should == true
+      expect(@check.is_vulnerable_version?('2.3.0', '2.3.0.rc9')).to eq(true)
     end
     it "reports a safe condition when a rc version is safe and the stable version is detected" do
-      @check.is_vulnerable_version?('2.3.0.rc9', '2.3.0').should == false
+      expect(@check.is_vulnerable_version?('2.3.0.rc9', '2.3.0')).to eq(false)
     end
     it "reports a vulnerability when a previous rc version is detected" do
-      @check.is_vulnerable_version?('2.3.0', '2.2.10.rc2').should == true
+      expect(@check.is_vulnerable_version?('2.3.0', '2.2.10.rc2')).to eq(true)
     end
     it "reports a safe condition when a rc version is detected but the safe version was released earlier (same major, same minor)" do
-      @check.is_vulnerable_version?('2.2.0', '2.2.10.rc2').should == false
+      expect(@check.is_vulnerable_version?('2.2.0', '2.2.10.rc2')).to eq(false)
     end
     it "reports a safe condition when a rc version is detected but the safe version was released earlier (same major)" do
-      @check.is_vulnerable_version?('2.2.0', '2.4.10.rc2').should == false
+      expect(@check.is_vulnerable_version?('2.2.0', '2.4.10.rc2')).to eq(false)
     end
     it "reports a safe condition when a rc version is detected but the safe version was released earlier" do
-      @check.is_vulnerable_version?('2.2.0', '3.4.10.rc2').should == false
+      expect(@check.is_vulnerable_version?('2.2.0', '3.4.10.rc2')).to eq(false)
     end
   end
 
   context "with some pre versions to handle" do
     it "reports when a pre version is vulnerable" do
-      @check.is_vulnerable_version?('2.3.0.pre3', '2.3.0.pre1').should == true
+      expect(@check.is_vulnerable_version?('2.3.0.pre3', '2.3.0.pre1')).to eq(true)
     end
     it "reports when a pre version is not vulnerable" do
-      @check.is_vulnerable_version?('2.3.0.pre3', '2.3.0.pre5').should == false
+      expect(@check.is_vulnerable_version?('2.3.0.pre3', '2.3.0.pre5')).to eq(false)
     end
     it "reports when a pre version is not vulnerable (equals)" do
-      @check.is_vulnerable_version?('2.3.0.pre5', '2.3.0.pre5').should == false
+      expect(@check.is_vulnerable_version?('2.3.0.pre5', '2.3.0.pre5')).to eq(false)
     end
     it "reports a vulnerability when a stable version is safe and pre is detected" do
-      @check.is_vulnerable_version?('2.3.0', '2.3.0.pre9').should == true
+      expect(@check.is_vulnerable_version?('2.3.0', '2.3.0.pre9')).to eq(true)
     end
     it "reports a safe condition when a pre version is safe and the stable version is detected" do
-      @check.is_vulnerable_version?('2.3.0.pre9', '2.3.0').should == false
+      expect(@check.is_vulnerable_version?('2.3.0.pre9', '2.3.0')).to eq(false)
     end
     it "reports a vulnerability when a previous pre version is detected" do
-      @check.is_vulnerable_version?('2.3.0', '2.2.10.pre2').should == true
+      expect(@check.is_vulnerable_version?('2.3.0', '2.2.10.pre2')).to eq(true)
     end
     it "reports a safe condition when a pre version is detected but the safe version was released earlier (same major, same minor)" do
-      @check.is_vulnerable_version?('2.2.0', '2.2.10.pre2').should == false
+      expect(@check.is_vulnerable_version?('2.2.0', '2.2.10.pre2')).to eq(false)
     end
     it "reports a safe condition when a pre version is detected but the safe version was released earlier (same major)" do
-      @check.is_vulnerable_version?('2.2.0', '2.4.10.pre2').should == false
+      expect(@check.is_vulnerable_version?('2.2.0', '2.4.10.pre2')).to eq(false)
     end
     it "reports a safe condition when a pre version is detected but the safe version was released earlier" do
-      @check.is_vulnerable_version?('2.2.0', '3.4.10.pre2').should == false
+      expect(@check.is_vulnerable_version?('2.2.0', '3.4.10.pre2')).to eq(false)
     end
   end
   # deprecation check
   it "reports nonsense deprecation" do
     nonsense = Dawn::Kb::VersionCheck.new
     nonsense.deprecated = ['x.0.0']
-    nonsense.is_deprecated?('2.2.3').should == true
+    expect(nonsense.is_deprecated?('2.2.3')).to eq(true)
   end
 
   it "tells 1.1.12 is deprecated" do
-    @check.is_deprecated?('1.1.12').should == true
+    expect(@check.is_deprecated?('1.1.12')).to eq(true)
   end
   it "tells 0.1.12 is deprecated" do
-    @check.is_deprecated?('0.1.12').should == true
+    expect(@check.is_deprecated?('0.1.12')).to eq(true)
   end
   it "tells 0.4.12 is not deprecated" do
-    @check.is_deprecated?('0.4.12').should == false
+    expect(@check.is_deprecated?('0.4.12')).to eq(false)
   end
   context "applied as it should be" do
     it "says a version 0.4.6 is safe" do
       @check.detected = '0.4.6'
       @check.save_minor = true
-      @check.vuln?.should   == false
+      expect(@check.vuln?).to   eq(false)
     end
   end
 end