ronin-support 0.5.1 → 0.5.2

data/spec/network/dns_spec.rb

@@ -8,7 +8,7 @@ describe Network::DNS do
 
   describe "nameserver" do
     it "should be nil by default" do
-      subject.nameserver.should be_nil
+      expect(subject.nameserver).to be_nil
     end
   end
 
@@ -16,20 +16,20 @@ describe Network::DNS do
     it "should accept Strings" do
       subject.nameserver = server
 
-      subject.nameserver.should == server
+      expect(subject.nameserver).to eq(server)
     end
 
     it "should accept nil" do
       subject.nameserver = server
       subject.nameserver = nil
 
-      subject.nameserver.should be_nil
+      expect(subject.nameserver).to be_nil
     end
 
     it "should convert non-nil values to Strings" do
       subject.nameserver = IPAddr.new(server)
 
-      subject.nameserver.should == server
+      expect(subject.nameserver).to eq(server)
     end
   end
 
@@ -41,19 +41,21 @@ describe Network::DNS do
     end
 
     it "should return Resolv when passed no nameserver" do
-      subject.dns_resolver(nil).should == Resolv
+      expect(subject.dns_resolver(nil)).to eq(Resolv)
     end
 
     it "should return Resolv::DNS when passed a nameserver" do
-      subject.dns_resolver(server).should be_kind_of(Resolv::DNS)
+      expect(subject.dns_resolver(server)).to be_kind_of(Resolv::DNS)
     end
   end
 
   describe "helper methods", :network do
     let(:hostname)         { 'example.com' }
     let(:bad_hostname)     { 'foo.bar' }
-    let(:address)          { '192.0.43.10' }
+    let(:address)          { '93.184.216.34' }
     let(:bad_address)      { '0.0.0.0' }
+    let(:reverse_address)  { '192.0.43.10' }
+    let(:reverse_ipaddr)   { IPAddr.new(reverse_address) }
     let(:reverse_hostname) { '43-10.any.icann.org' }
 
     subject do
@@ -64,19 +66,19 @@ describe Network::DNS do
 
     describe "#dns_lookup" do
       it "should lookup the address for a hostname" do
-        subject.dns_lookup(hostname).should == address
+        expect(subject.dns_lookup(hostname)).to eq(address)
       end
 
       it "should return nil for unknown hostnames" do
-        subject.dns_lookup(bad_hostname).should be_nil
+        expect(subject.dns_lookup(bad_hostname)).to be_nil
       end
 
       it "should accept non-String hostnames" do
-        subject.dns_lookup(hostname.to_sym).should == address
+        expect(subject.dns_lookup(hostname.to_sym)).to eq(address)
       end
 
       it "should accept an additional nameserver argument" do
-        subject.dns_lookup(hostname,server).should == address
+        expect(subject.dns_lookup(hostname,server)).to eq(address)
       end
 
       context "when given a block" do
@@ -87,7 +89,7 @@ describe Network::DNS do
             resolved_address = address
           end
 
-          resolved_address.should == address
+          expect(resolved_address).to eq(address)
         end
 
         it "should not yield unresolved addresses" do
@@ -97,65 +99,65 @@ describe Network::DNS do
             resolved_address = address
           end
 
-          resolved_address.should be_nil
+          expect(resolved_address).to be_nil
         end
       end
     end
 
     describe "#dns_lookup_all" do
       it "should lookup all addresses for a hostname" do
-        subject.dns_lookup_all(hostname).should include(address)
+        expect(subject.dns_lookup_all(hostname)).to include(address)
       end
 
       it "should return an empty Array for unknown hostnames" do
-        subject.dns_lookup_all(bad_hostname).should == []
+        expect(subject.dns_lookup_all(bad_hostname)).to eq([])
       end
 
       it "should accept non-String hostnames" do
-        subject.dns_lookup_all(hostname.to_sym).should include(address)
+        expect(subject.dns_lookup_all(hostname.to_sym)).to include(address)
       end
 
       it "should accept an additional nameserver argument" do
-        subject.dns_lookup_all(hostname,server).should include(address)
+        expect(subject.dns_lookup_all(hostname,server)).to include(address)
       end
 
       context "when given a block" do
         it "should yield the resolved address" do
-          subject.enum_for(:dns_lookup,hostname).to_a.should == [address]
+          expect(subject.enum_for(:dns_lookup,hostname).to_a).to eq([address])
         end
 
         it "should not yield unresolved addresses" do
-          subject.enum_for(:dns_lookup,bad_hostname).to_a.should == []
+          expect(subject.enum_for(:dns_lookup,bad_hostname).to_a).to eq([])
         end
       end
     end
 
     describe "#dns_reverse_lookup" do
       it "should lookup the address for a hostname" do
-        subject.dns_reverse_lookup(address).should == reverse_hostname
+        expect(subject.dns_reverse_lookup(reverse_address)).to eq(reverse_hostname)
       end
 
       it "should return nil for unknown hostnames" do
-        subject.dns_reverse_lookup(bad_address).should be_nil
+        expect(subject.dns_reverse_lookup(bad_address)).to be_nil
       end
 
       it "should accept non-String addresses" do
-        subject.dns_reverse_lookup(IPAddr.new(address)).should == reverse_hostname
+        expect(subject.dns_reverse_lookup(reverse_ipaddr)).to eq(reverse_hostname)
       end
 
       it "should accept an additional nameserver argument" do
-        subject.dns_reverse_lookup(address,server).should == reverse_hostname
+        expect(subject.dns_reverse_lookup(reverse_address,server)).to eq(reverse_hostname)
       end
 
       context "when given a block" do
         it "should yield the resolved hostname" do
           resolved_hostname = nil
 
-          subject.dns_reverse_lookup(address) do |hostname|
+          subject.dns_reverse_lookup(reverse_address) do |hostname|
             resolved_hostname = hostname
           end
 
-          resolved_hostname.should == reverse_hostname
+          expect(resolved_hostname).to eq(reverse_hostname)
         end
 
         it "should not yield unresolved hostnames" do
@@ -165,35 +167,35 @@ describe Network::DNS do
             resolved_hostname = hostname
           end
 
-          resolved_hostname.should be_nil
+          expect(resolved_hostname).to be_nil
         end
       end
     end
 
     describe "#dns_reverse_lookup_all" do
       it "should lookup all addresses for a hostname" do
-        subject.dns_reverse_lookup_all(address).should include(reverse_hostname)
+        expect(subject.dns_reverse_lookup_all(reverse_address)).to include(reverse_hostname)
       end
 
       it "should return an empty Array for unknown hostnames" do
-        subject.dns_reverse_lookup_all(bad_address).should == []
+        expect(subject.dns_reverse_lookup_all(bad_address)).to eq([])
       end
 
       it "should accept non-String addresses" do
-        subject.dns_reverse_lookup_all(IPAddr.new(address)).should include(reverse_hostname)
+        expect(subject.dns_reverse_lookup_all(reverse_ipaddr)).to include(reverse_hostname)
       end
 
       it "should accept an additional nameserver argument" do
-        subject.dns_reverse_lookup_all(address,server).should include(reverse_hostname)
+        expect(subject.dns_reverse_lookup_all(reverse_address,server)).to include(reverse_hostname)
       end
 
       context "when given a block" do
         it "should yield the resolved hostnames" do
-          subject.enum_for(:dns_reverse_lookup_all,address).to_a.should == [reverse_hostname]
+          expect(subject.enum_for(:dns_reverse_lookup_all,reverse_address).to_a).to eq([reverse_hostname])
         end
 
         it "should not yield unresolved hostnames" do
-          subject.enum_for(:dns_reverse_lookup_all,bad_address).to_a.should == []
+          expect(subject.enum_for(:dns_reverse_lookup_all,bad_address).to_a).to eq([])
         end
       end
     end

data/spec/network/ftp_spec.rb

@@ -9,20 +9,20 @@ describe Network::FTP do
       obj
     end
 
-    let(:host) { 'ftp.kernel.org' }
+    let(:host) { 'ftp.osuosl.org' }
 
     describe "#ftp_connect" do
       it "should return a Net::FTP object" do
         ftp = subject.ftp_connect(host)
 
-        ftp.should be_kind_of(Net::FTP)
+        expect(ftp).to be_kind_of(Net::FTP)
         ftp.close
       end
 
       it "should connect to an FTP service" do
         ftp = subject.ftp_connect(host)
 
-        ftp.should_not be_closed
+        expect(ftp).not_to be_closed
         ftp.close
       end
 
@@ -30,14 +30,14 @@ describe Network::FTP do
         it "should set passive mode by default" do
           ftp = subject.ftp_connect(host)
 
-          ftp.passive.should be_true
+          expect(ftp.passive).to be(true)
           ftp.close
         end
 
         it "should allow disabling passive mode" do
           ftp = subject.ftp_connect(host, :passive => false)
 
-          ftp.passive.should be_false
+          expect(ftp.passive).to be(false)
           ftp.close
         end
       end
@@ -45,7 +45,7 @@ describe Network::FTP do
       context "when given a block" do
         it "should yield the new Net::FTP object" do
           ftp = subject.ftp_connect(host) do |ftp|
-            ftp.should be_kind_of(Net::FTP)
+            expect(ftp).to be_kind_of(Net::FTP)
           end
 
           ftp.close
@@ -61,7 +61,7 @@ describe Network::FTP do
           yielded_ftp = ftp
         end
 
-        yielded_ftp.should be_kind_of(Net::FTP)
+        expect(yielded_ftp).to be_kind_of(Net::FTP)
       end
 
       it "should close the FTP session after yielding it" do
@@ -73,8 +73,8 @@ describe Network::FTP do
           was_open  = !ftp.closed?
         end
 
-        was_open.should == true
-        session.should be_closed
+        expect(was_open).to be(true)
+        expect(session).to be_closed
       end
     end
   end

data/spec/network/http/http_spec.rb

@@ -4,7 +4,7 @@ require 'ronin/network/http'
 describe Network::HTTP do
   describe "proxy" do
     it "should be disabled by default" do
-      subject.proxy.should_not be_enabled
+      expect(subject.proxy).not_to be_enabled
     end
   end
 
@@ -14,7 +14,7 @@ describe Network::HTTP do
     it "should accept URI objects" do
       options = subject.expand_url(url)
 
-      options[:host].should == url.host
+      expect(options[:host]).to eq(url.host)
     end
 
     it "should accept Hashes" do
@@ -24,33 +24,61 @@ describe Network::HTTP do
       }
       options = subject.expand_url(hash)
 
-      options[:host].should == url.host
-      options[:port].should == url.port
+      expect(options[:host]).to eq(url.host)
+      expect(options[:port]).to eq(url.port)
     end
 
     it "should accept Strings" do
       options = subject.expand_url(url.to_s)
 
-      options[:host].should == url.host
-      options[:port].should == url.port
+      expect(options[:host]).to eq(url.host)
+      expect(options[:port]).to eq(url.port)
     end
 
-    it "should default :path to '/'" do
-      options = subject.expand_url(URI('http://example.com'))
+    describe ":path" do
+      it "should filter out empty URL paths" do
+        options = subject.expand_url(URI('http://example.com'))
 
-      options[:path].should == '/'
+        expect(options[:path]).to be_nil
+      end
+
+      context "when the path is empty" do
+        it "should not be set" do
+          options = subject.expand_url(URI('http://example.com'))
+
+          expect(options).not_to have_key(:path)
+        end
+      end
     end
 
-    it "should append the query-string to the :path options" do
-      options = subject.expand_url(url)
+    describe ":query" do
+      it "should set :query to the query string" do
+        options = subject.expand_url(url)
+
+        expect(options[:query]).to eq(url.query)
+      end
+
+      context "when query is nil" do
+        it "should not be set" do
+          options = subject.expand_url(URI('http://example.com/path'))
 
-      options[:path].should == "#{url.path}?#{url.query}"
+          expect(options).not_to have_key(:query)
+        end
+      end
+
+      context "when query is empty" do
+        it "should be set" do
+          options = subject.expand_url(URI('http://example.com/path?'))
+
+          expect(options[:query]).to be_empty
+        end
+      end
     end
 
     it "should set :ssl if the URI scheme is 'https'" do
       options = subject.expand_url(URI('https://example.com'))
 
-      options[:ssl].should == {}
+      expect(options[:ssl]).to eq({})
     end
   end
 
@@ -59,30 +87,30 @@ describe Network::HTTP do
       options = {:ssl => true}
       expanded_options = subject.expand_options(options)
 
-      expanded_options[:ssl].should == {}
+      expect(expanded_options[:ssl]).to eq({})
     end
 
     it "should added a default port and path" do
       options = {:host => 'example.com'}
       expanded_options = subject.expand_options(options)
 
-      expanded_options[:port].should == 80
-      expanded_options[:path].should == '/'
+      expect(expanded_options[:port]).to eq(80)
+      expect(expanded_options[:path]).to eq('/')
     end
 
     it "should add the default proxy settings" do
       options = {:host => 'example.com'}
       expanded_options = subject.expand_options(options)
 
-      expanded_options[:proxy].should == subject.proxy
+      expect(expanded_options[:proxy]).to eq(subject.proxy)
     end
 
     it "should disable the proxy settings if :proxy is nil" do
       options = {:host => 'example.com', :proxy => nil}
       expanded_options = subject.expand_options(options)
 
-      expanded_options[:proxy][:host].should be_nil
-      expanded_options[:proxy][:port].should be_nil
+      expect(expanded_options[:proxy][:host]).to be_nil
+      expect(expanded_options[:proxy][:port]).to be_nil
     end
 
     it "should not modify :proxy if it is a HTTP::Proxy object" do
@@ -90,184 +118,249 @@ describe Network::HTTP do
       options = {:host => 'example.com', :proxy => proxy}
       expanded_options = subject.expand_options(options)
 
-      expanded_options[:proxy].should == proxy
+      expect(expanded_options[:proxy]).to eq(proxy)
     end
 
     it "should parse the :proxy option" do
       options = {:host => 'example.com', :proxy => 'http://proxy.com:8181'}
       expanded_options = subject.expand_options(options)
 
-      expanded_options[:proxy][:host].should == 'proxy.com'
-      expanded_options[:proxy][:port].should == 8181
+      expect(expanded_options[:proxy][:host]).to eq('proxy.com')
+      expect(expanded_options[:proxy][:port]).to eq(8181)
     end
 
     it "should expand the :url option" do
       options = {:url => 'http://joe:secret@example.com:8080/bla?var'}
       expanded_options = subject.expand_options(options)
 
-      expanded_options[:url].should be_nil
-      expanded_options[:host].should == 'example.com'
-      expanded_options[:port].should == 8080
-      expanded_options[:user].should == 'joe'
-      expanded_options[:password].should == 'secret'
-      expanded_options[:path].should == '/bla?var'
+      expect(expanded_options[:url]).to be_nil
+      expect(expanded_options[:host]).to eq('example.com')
+      expect(expanded_options[:port]).to eq(8080)
+      expect(expanded_options[:user]).to eq('joe')
+      expect(expanded_options[:password]).to eq('secret')
+      expect(expanded_options[:path]).to eq('/bla')
+      expect(expanded_options[:query]).to eq('var')
     end
-
   end
 
   describe "headers" do
     it "should convert Symbol options to HTTP Headers" do
       options = {:user_agent => 'bla', :location => 'test'}
 
-      subject.headers(options).should == {
+      expect(subject.headers(options)).to eq({
         'User-Agent' => 'bla',
-        'Location' => 'test'
-      }
+        'Location'   => 'test'
+      })
     end
 
     it "should convert String options to HTTP Headers" do
       options = {'user_agent' => 'bla', 'x-powered-by' => 'PHP'}
 
-      subject.headers(options).should == {
-        'User-Agent' => 'bla',
+      expect(subject.headers(options)).to eq({
+        'User-Agent'   => 'bla',
         'X-Powered-By' => 'PHP'
-      }
+      })
     end
 
     it "should convert all values to Strings" do
       mtime = Time.now.to_i
       options = {:modified_by => mtime, :x_accept => :gzip}
 
-      subject.headers(options).should == {
+      expect(subject.headers(options)).to eq({
         'Modified-By' => mtime.to_s,
-        'X-Accept' => 'gzip'
-      }
+        'X-Accept'    => 'gzip'
+      })
     end
   end
 
   describe "request" do
     it "should handle Symbol names" do
-      subject.request(
+      expect(subject.request(
         :method => :get, :path => '/'
-      ).class.should == Net::HTTP::Get
+      ).class).to eq(Net::HTTP::Get)
     end
 
     it "should handle String names" do
-      subject.request(
+      expect(subject.request(
         :method => 'GET', :path => '/'
-      ).class.should == Net::HTTP::Get
+      ).class).to eq(Net::HTTP::Get)
     end
 
-    it "should raise an UnknownRequest exception for invalid names" do
-      lambda {
-        subject.request(:method => :bla)
-      }.should raise_error(subject::UnknownRequest)
-    end
+    context "with :path" do
+      it "should use a default path" do
+        expect {
+          subject.request(:method => :get)
+        }.not_to raise_error
+      end
+
+      it "should set the path" do
+        req = subject.request(:method => :get, :path => '/foo')
 
-    it "should use a default path" do
-      lambda {
-        subject.request(:method => :get)
-      }.should_not raise_error(ArgumentError)
+        expect(req.path).to eq('/foo')
+      end
     end
 
-    it "should accept the :user option for Basic-Auth" do
-      req = subject.request(:method => :get, :user => 'joe')
+    context "with :query" do
+      let(:path)  { '/foo' }
+      let(:query) { 'q=1' }
 
-      req['authorization'].should == "Basic am9lOg=="
-    end
+      it "should append the query-string to the path" do
+        req = subject.request(
+          :method => :get,
+          :path   => path,
+          :query  => query
+        )
 
-    it "should accept the :user and :password options for Basic-Auth" do
-      req = subject.request(
-        :method => :get,
-        :user => 'joe',
-        :password => 'secret'
-      )
+        expect(req.path).to eq("#{path}?#{query}")
+      end
 
-      req['authorization'].should == "Basic am9lOnNlY3JldA=="
-    end
+      context "when path already contains a query string" do
+        let(:additional_query) { 'x=2' }
 
-    it "should create HTTP Copy requests" do
-      req = subject.request(:method => :copy)
+        it "should append the query using a '&' character" do
+          req = subject.request(
+            :method => :get,
+            :path   => "#{path}?#{query}",
+            :query  => additional_query
+          )
 
-      req.class.should == Net::HTTP::Copy
-    end
+          expect(req.path).to eq("#{path}?#{query}&#{additional_query}")
+        end
 
-    it "should create HTTP Delete requests" do
-      req = subject.request(:method => :delete)
+        context "when :query is empty" do
+          it "should append an extra '&'" do
+            req = subject.request(
+              :method => :get,
+              :path   => "#{path}?#{query}",
+              :query  => ''
+            )
 
-      req.class.should == Net::HTTP::Delete
-    end
+            expect(req.path).to be_end_with('&')
+          end
+        end
+      end
 
-    it "should create HTTP Get requests" do
-      req = subject.request(:method => :get)
+      context "when :query is empty" do
+        it "should append an extra '?'" do
+          req = subject.request(
+            :method => :get,
+            :path   => path,
+            :query  => ''
+          )
 
-      req.class.should == Net::HTTP::Get
+          expect(req.path).to be_end_with('?')
+        end
+      end
     end
 
-    it "should create HTTP Head requests" do
-      req = subject.request(:method => :head)
+    context "with :user and :password" do
+      it "should accept the :user option for Basic-Auth" do
+        req = subject.request(:method => :get, :user => 'joe')
 
-      req.class.should == Net::HTTP::Head
-    end
+        expect(req['authorization']).to eq("Basic am9lOg==")
+      end
 
-    it "should create HTTP Lock requests" do
-      req = subject.request(:method => :lock)
+      it "should also accept the :password options for Basic-Auth" do
+        req = subject.request(
+          :method => :get,
+          :user => 'joe',
+          :password => 'secret'
+        )
 
-      req.class.should == Net::HTTP::Lock
+        expect(req['authorization']).to eq("Basic am9lOnNlY3JldA==")
+      end
     end
 
-    it "should create HTTP Mkcol requests" do
-      req = subject.request(:method => :mkcol)
+    context "with :method" do
+      it "should create HTTP Copy requests" do
+        req = subject.request(:method => :copy)
 
-      req.class.should == Net::HTTP::Mkcol
-    end
+        expect(req.class).to eq(Net::HTTP::Copy)
+      end
 
-    it "should create HTTP Move requests" do
-      req = subject.request(:method => :move)
+      it "should create HTTP Delete requests" do
+        req = subject.request(:method => :delete)
 
-      req.class.should == Net::HTTP::Move
-    end
+        expect(req.class).to eq(Net::HTTP::Delete)
+      end
 
-    it "should create HTTP Options requests" do
-      req = subject.request(:method => :options)
+      it "should create HTTP Get requests" do
+        req = subject.request(:method => :get)
 
-      req.class.should == Net::HTTP::Options
-    end
+        expect(req.class).to eq(Net::HTTP::Get)
+      end
 
-    it "should create HTTP Post requests" do
-      req = subject.request(:method => :post)
+      it "should create HTTP Head requests" do
+        req = subject.request(:method => :head)
 
-      req.class.should == Net::HTTP::Post
-    end
+        expect(req.class).to eq(Net::HTTP::Head)
+      end
 
-    it "should create HTTP Propfind requests" do
-      req = subject.request(:method => :propfind)
+      it "should create HTTP Lock requests" do
+        req = subject.request(:method => :lock)
 
-      req.class.should == Net::HTTP::Propfind
-    end
+        expect(req.class).to eq(Net::HTTP::Lock)
+      end
 
-    it "should create HTTP Proppatch requests" do
-      req = subject.request(:method => :proppatch)
+      it "should create HTTP Mkcol requests" do
+        req = subject.request(:method => :mkcol)
 
-      req.class.should == Net::HTTP::Proppatch
-    end
+        expect(req.class).to eq(Net::HTTP::Mkcol)
+      end
 
-    it "should create HTTP Trace requests" do
-      req = subject.request(:method => :trace)
+      it "should create HTTP Move requests" do
+        req = subject.request(:method => :move)
 
-      req.class.should == Net::HTTP::Trace
-    end
+        expect(req.class).to eq(Net::HTTP::Move)
+      end
+
+      it "should create HTTP Options requests" do
+        req = subject.request(:method => :options)
 
-    it "should create HTTP Unlock requests" do
-      req = subject.request(:method => :unlock)
+        expect(req.class).to eq(Net::HTTP::Options)
+      end
+
+      it "should create HTTP Post requests" do
+        req = subject.request(:method => :post)
+
+        expect(req.class).to eq(Net::HTTP::Post)
+      end
+
+      it "should create HTTP Propfind requests" do
+        req = subject.request(:method => :propfind)
 
-      req.class.should == Net::HTTP::Unlock
+        expect(req.class).to eq(Net::HTTP::Propfind)
+      end
+
+      it "should create HTTP Proppatch requests" do
+        req = subject.request(:method => :proppatch)
+
+        expect(req.class).to eq(Net::HTTP::Proppatch)
+      end
+
+      it "should create HTTP Trace requests" do
+        req = subject.request(:method => :trace)
+
+        expect(req.class).to eq(Net::HTTP::Trace)
+      end
+
+      it "should create HTTP Unlock requests" do
+        req = subject.request(:method => :unlock)
+
+        expect(req.class).to eq(Net::HTTP::Unlock)
+      end
+
+      it "should raise an UnknownRequest exception for invalid methods" do
+        expect {
+          subject.request(:method => :bla)
+        }.to raise_error(subject::UnknownRequest)
+      end
     end
 
     it "should raise an ArgumentError when :method is not specified" do
-      lambda {
+      expect {
         subject.request()
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -287,8 +380,8 @@ describe Network::HTTP do
       it "should create a Net::HTTP session" do
         http = subject.http_connect(:host => host, :port => port)
         
-        http.should be_kind_of(Net::HTTP)
-        http.should be_started
+        expect(http).to be_kind_of(Net::HTTP)
+        expect(http).to be_started
 
         http.finish
       end
@@ -300,7 +393,7 @@ describe Network::HTTP do
           http = session
         end
 
-        http.should be_kind_of(Net::HTTP)
+        expect(http).to be_kind_of(Net::HTTP)
       end
 
       it "should allow yielding the expanded options" do
@@ -310,9 +403,9 @@ describe Network::HTTP do
           expanded_options = options
         end
 
-        expanded_options[:host].should == host
-        expanded_options[:port].should == port
-        expanded_options[:path].should == path
+        expect(expanded_options[:host]).to eq(host)
+        expect(expanded_options[:port]).to eq(port)
+        expect(expanded_options[:path]).to eq(path)
       end
     end
 
@@ -324,8 +417,8 @@ describe Network::HTTP do
           http = session
         end
         
-        http.should be_kind_of(Net::HTTP)
-        http.should_not be_started
+        expect(http).to be_kind_of(Net::HTTP)
+        expect(http).not_to be_started
       end
 
       it "should allow yielding the Net::HTTP session" do
@@ -335,7 +428,7 @@ describe Network::HTTP do
           http = session
         end
         
-        http.should be_kind_of(Net::HTTP)
+        expect(http).to be_kind_of(Net::HTTP)
       end
 
       it "should allow yielding the expanded options" do
@@ -345,9 +438,9 @@ describe Network::HTTP do
           expanded_options = options
         end
 
-        expanded_options[:host].should == host
-        expanded_options[:port].should == port
-        expanded_options[:path].should == path
+        expect(expanded_options[:host]).to eq(host)
+        expect(expanded_options[:port]).to eq(port)
+        expect(expanded_options[:path]).to eq(path)
       end
     end
 
@@ -355,7 +448,7 @@ describe Network::HTTP do
       it "should send an arbitrary request and return the response" do
         response = subject.http_request(:url => uri, :method => :options)
 
-        response.should be_kind_of(Net::HTTPMethodNotAllowed)
+        expect(response).to be_kind_of(Net::HTTPMethodNotAllowed)
       end
 
       it "should allow yielding the request" do
@@ -365,7 +458,7 @@ describe Network::HTTP do
           request = req
         end
 
-        request.should be_kind_of(Net::HTTP::Options)
+        expect(request).to be_kind_of(Net::HTTP::Options)
       end
 
       it "should allow yielding the expanded options" do
@@ -375,25 +468,25 @@ describe Network::HTTP do
           expanded_options = options
         end
         
-        expanded_options[:host].should == host
-        expanded_options[:port].should == port
-        expanded_options[:path].should == path
+        expect(expanded_options[:host]).to eq(host)
+        expect(expanded_options[:port]).to eq(port)
+        expect(expanded_options[:path]).to eq(path)
       end
     end
 
     describe "#http_status" do
       it "should return an Integer" do
-        subject.http_status(:url => uri).should be_kind_of(Integer)
+        expect(subject.http_status(:url => uri)).to be_kind_of(Integer)
       end
 
       it "should return the status-code of the Response" do
-        subject.http_status(:url => uri).should == 200
+        expect(subject.http_status(:url => uri)).to eq(200)
       end
     end
 
     describe "#http_ok?" do
       it "should check if the Response has code 200" do
-        subject.http_ok?(:url => uri).should == true
+        expect(subject.http_ok?(:url => uri)).to be(true)
       end
     end
 
@@ -402,7 +495,7 @@ describe Network::HTTP do
       let(:headers) { subject.http_get_headers(:url => url) }
 
       it "should return the 'Server' header" do
-        subject.http_server(:url => url).should == headers['Server']
+        expect(subject.http_server(:url => url)).to eq(headers['Server'])
       end
     end
 
@@ -411,7 +504,7 @@ describe Network::HTTP do
       let(:headers) { subject.http_get_headers(:url => url) }
 
       it "should return the 'X-Powered-By' header" do
-        subject.http_powered_by(:url => url).should == headers['X-Powered-By']
+        expect(subject.http_powered_by(:url => url)).to eq(headers['X-Powered-By'])
       end
     end
 
@@ -419,14 +512,14 @@ describe Network::HTTP do
       let(:headers) { subject.http_get_headers(:url => uri) }
 
       it "should return HTTP Headers" do
-        headers.should_not be_empty
+        expect(headers).not_to be_empty
       end
 
       it "should format the HTTP Headers accordingly" do
         format = /^[A-Z][a-z0-9]*(-[A-Z][a-z0-9]*)*$/
         bad_headers = headers.keys.reject { |name| name =~ format }
 
-        bad_headers.should == []
+        expect(bad_headers).to eq([])
       end
     end
 
@@ -434,8 +527,8 @@ describe Network::HTTP do
       it "should return the response body" do
         body = subject.http_get_body(:url => uri)
 
-        body.should be_kind_of(String)
-        body.should_not be_empty
+        expect(body).to be_kind_of(String)
+        expect(body).not_to be_empty
       end
     end
 
@@ -443,14 +536,14 @@ describe Network::HTTP do
       let(:headers) { subject.http_post_headers(:url => uri) }
 
       it "should return HTTP Headers" do
-        headers.should_not be_empty
+        expect(headers).not_to be_empty
       end
 
       it "should format the HTTP Headers accordingly" do
         format = /^[A-Z][a-z0-9]*(-[A-Z][a-z0-9]*)*$/
         bad_headers = headers.keys.reject { |name| name =~ format }
 
-        bad_headers.should == []
+        expect(bad_headers).to eq([])
       end
     end
 
@@ -458,8 +551,8 @@ describe Network::HTTP do
       it "should return the response body" do
         body = subject.http_post_body(:url => uri)
 
-        body.should be_kind_of(String)
-        body.should_not be_empty
+        expect(body).to be_kind_of(String)
+        expect(body).not_to be_empty
       end
     end
   end