ronin-exploits 0.3.1 → 1.0.0.beta1

data/spec/mixins/http_spec.rb

@@ -0,0 +1,1227 @@
+require 'spec_helper'
+require 'ronin/exploits/mixins/http'
+require 'ronin/exploits/exploit'
+
+describe Ronin::Exploits::Mixins::HTTP do
+  module TestMixinsHTTP
+    class TestExploit < Ronin::Exploits::Exploit
+      include Ronin::Exploits::Mixins::HTTP
+    end
+
+    class TestExploitWithDefaultHeaders < Ronin::Exploits::Exploit
+      include Ronin::Exploits::Mixins::HTTP
+
+      def http_headers
+        {'X-Foo' => 'bar'}
+      end
+    end
+  end
+
+  let(:test_class) { TestMixinsHTTP::TestExploit }
+
+  describe ".included" do
+    subject { test_class }
+
+    it "must define a 'http_proxy' param" do
+      expect(subject.params[:http_proxy]).to_not be_nil
+      expect(subject.params[:http_proxy].desc).to eq("The HTTP proxy to use")
+    end
+
+    it "must define a 'user_agent' param" do
+      expect(subject.params[:user_agent]).to_not be_nil
+      expect(subject.params[:user_agent].type).to be_kind_of(Ronin::Core::Params::Types::Enum)
+      expect(subject.params[:user_agent].type.values).to eq(
+        [
+          :random,
+          :chrome,
+          :firefox,
+          :safari,
+          :linux,
+          :macos,
+          :windows,
+          :iphone,
+          :ipad,
+          :android
+        ] + Ronin::Support::Network::HTTP::UserAgents::ALIASES.keys
+      )
+      expect(subject.params[:user_agent].desc).to eq("The HTTP User-Agent to select")
+    end
+
+    it "must define a 'raw_user_agent' param" do
+      expect(subject.params[:raw_user_agent]).to_not be_nil
+      expect(subject.params[:raw_user_agent].desc).to eq("The raw HTTP User-Agent string to use")
+    end
+  end
+
+  let(:base_url) { URI.parse("https://www.example.com/base") }
+
+  subject do
+    test_class.new(params: {base_url: base_url})
+  end
+
+  describe "#http_proxy" do
+    let(:proxy) { 'http://example.com:8080' }
+
+    subject do
+      test_class.new(params: {base_url: base_url, http_proxy: proxy})
+    end
+
+    it "must return params[:http_proxy]" do
+      expect(subject.http_proxy).to be(subject.params[:http_proxy])
+    end
+  end
+
+  describe "#http_headers" do
+    it "must return an empty Hash by default" do
+      expect(subject.http_headers).to eq({})
+    end
+  end
+
+  describe "#http_user_agent" do
+    context "when params[:user_agent] is set" do
+      let(:user_agent) { :random }
+
+      subject do
+        test_class.new(
+          params: {
+            base_url:   base_url,
+            user_agent: user_agent
+          }
+        )
+      end
+
+      it "must return params[:user_agent]" do
+        expect(subject.http_user_agent).to be(subject.params[:user_agent])
+      end
+    end
+
+    context "when params[:raw_user_agent] is set" do
+      let(:raw_user_agent) { 'Mozilla/5.0 Foo Bar' }
+
+      subject do
+        test_class.new(
+          params: {
+            base_url:       base_url,
+            raw_user_agent: raw_user_agent
+          }
+        )
+      end
+
+      it "must return params[:raw_user_agent]" do
+        expect(subject.http_user_agent).to be(
+          subject.params[:raw_user_agent]
+        )
+      end
+    end
+
+    context "when both params[:user_agent] and params[:raw_user_agent] are set" do
+      let(:user_agent)     { :random }
+      let(:raw_user_agent) { 'Mozilla/5.0 Foo Bar' }
+
+      subject do
+        test_class.new(
+          params: {
+            base_url:          base_url,
+            user_agent:        user_agent,
+            raw_user_agent: raw_user_agent
+          }
+        )
+      end
+
+      it "must return params[:raw_user_agent]" do
+        expect(subject.http_user_agent).to be(
+          subject.params[:raw_user_agent]
+        )
+      end
+    end
+  end
+
+  describe "#http_cookie" do
+    context "when the http_cookie param is set" do
+      let(:cookie) { "foo=1; bar=2" }
+
+      subject do
+        test_class.new(
+          params: {
+            base_url:    base_url,
+            http_cookie: cookie
+          }
+        )
+      end
+
+      it "must return params[:http_cookie]" do
+        expect(subject.http_cookie).to eq(cookie)
+      end
+    end
+  end
+
+  let(:proxy)          { URI('https://proxy.example.com:8080') }
+  let(:raw_user_agent) { 'Mozilla/5.0 Foo Bar' }
+  let(:cookie)         { "foo=1; bar=2" }
+  let(:user)           { 'bob' }
+  let(:password)       { 'secret' }
+
+  subject do
+    test_class.new(
+      params: {
+        base_url:       base_url,
+        http_proxy:     proxy,
+        raw_user_agent: raw_user_agent,
+        http_cookie:    cookie,
+        http_user:      user,
+        http_password:  password
+      }
+    )
+  end
+
+  describe "#http" do
+    it "must call Ronin::Support::Network::HTTP.connect_uri with #params[:base_url], proxy: #http_proxy, headers: #http_headers, user_agent: #http_user_agent, cookie: #http_cookie, user: #http_user, password: #http_password" do
+      expect(Ronin::Support::Network::HTTP).to receive(:connect_uri).with(
+        subject.params[:base_url], proxy:      subject.http_proxy,
+                                   headers:    subject.http_headers,
+                                   user_agent: subject.http_user_agent,
+                                   cookie:     subject.http_cookie,
+                                   user:       subject.http_user,
+                                   password:   subject.http_password
+      )
+
+      subject.http
+    end
+
+    it "must return a Ronin::Support::Network::HTTP instance" do
+      expect(subject.http).to be_kind_of(Ronin::Support::Network::HTTP)
+    end
+
+    it "must return the same instance each time" do
+      expect(subject.http).to be(subject.http)
+    end
+
+    context "when #http_headers is overriden" do
+      let(:test_class) { TestMixinsHTTP::TestExploitWithDefaultHeaders }
+
+      it "must initialize #http.headers to the value of #http_headers" do
+        expect(subject.http.headers).to eq(subject.http_headers)
+      end
+    end
+  end
+
+  describe "#http_request" do
+    context "when given a request method and a path" do
+      let(:request_method) { :get }
+      let(:path)           { '/foo' }
+
+      it "must call #http.request with the request method and path" do
+        expect(subject.http).to receive(:request).with(request_method,path)
+
+        subject.http_request(request_method,path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:request).with(
+            request_method, path
+          )
+
+          expect(subject).to receive(:print_debug).with(
+            "Sending #{request_method.upcase} request to #{url} ..."
+          )
+
+          subject.http_request(request_method,path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_response_status" do
+    context "when given a request method and a path" do
+      let(:request_method) { :get }
+      let(:path)           { '/foo' }
+
+      it "must call #http.response_status with the request method and path" do
+        expect(subject.http).to receive(:response_status).with(
+          request_method, path
+        )
+
+        subject.http_response_status(request_method,path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:response_status).with(
+            request_method, path
+          )
+
+          expect(subject).to receive(:print_debug).with(
+            "Checking response status for #{request_method.upcase} #{url} ..."
+          )
+
+          subject.http_response_status(request_method,path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_ok?" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.ok? with :head and the path" do
+        expect(subject.http).to receive(:ok?).with(:head,path)
+
+        subject.http_ok?(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:ok?).with(:head,path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Checking if response status for HEAD #{url} is 200 ..."
+          )
+
+          subject.http_ok?(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+
+    context "when given a request method and a path" do
+      let(:request_method) { :get }
+      let(:path)           { '/foo' }
+
+      it "must call #http.ok? with the request method and the path" do
+        expect(subject.http).to receive(:ok?).with(request_method,path)
+
+        subject.http_ok?(request_method,path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:ok?).with(request_method,path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Checking if response status for #{request_method.upcase} #{url} is 200 ..."
+          )
+
+          subject.http_ok?(request_method,path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_response_headers" do
+    context "when given a path" do
+      let(:request_method) { :get }
+      let(:path)           { '/foo' }
+
+      it "must call #http.ok? with :head and the path" do
+        expect(subject.http).to receive(:response_headers).with(:head,path)
+
+        subject.http_response_headers(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:response_headers).with(:head,path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting response headers for HEAD #{url} ..."
+          )
+
+          subject.http_response_headers(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+
+    context "when given a request method and a path" do
+      let(:request_method) { :get }
+      let(:path)           { '/foo' }
+
+      it "must call #http.ok? with the request method and the path" do
+        expect(subject.http).to receive(:response_headers).with(
+          request_method, path
+        )
+
+        subject.http_response_headers(request_method,path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:response_headers).with(
+            request_method, path
+          )
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting response headers for #{request_method.upcase} #{url} ..."
+          )
+
+          subject.http_response_headers(request_method,path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_server_header" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.server_header with the path and method: :head" do
+        expect(subject.http).to receive(:server_header).with(
+          path, method: :head
+        )
+
+        subject.http_server_header(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:server_header).with(
+            path, method: :head
+          )
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting the 'Server' header for HEAD #{url} ..."
+          )
+
+          subject.http_server_header(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+
+    context "when given a path and the method: keyword argument" do
+      let(:request_method) { :get }
+      let(:path)           { '/foo' }
+
+      it "must call #http.server_header with the path and the method: keyword argument" do
+        expect(subject.http).to receive(:server_header).with(
+          path, method: request_method
+        )
+
+        subject.http_server_header(path, method: request_method)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:server_header).with(
+            path, method: request_method
+          )
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting the 'Server' header for #{request_method.upcase} #{url} ..."
+          )
+
+          subject.http_server_header(path, method: request_method)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_powered_by_header" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.powered_by_header with the path and method: :head" do
+        expect(subject.http).to receive(:powered_by_header).with(
+          path, method: :head
+        )
+
+        subject.http_powered_by_header(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:powered_by_header).with(
+            path, method: :head
+          )
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting the 'X-Powered-By' header for HEAD #{url} ..."
+          )
+
+          subject.http_powered_by_header(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+
+    context "when given a path and a method: keyword argument" do
+      let(:request_method) { :get   }
+      let(:path)           { '/foo' }
+
+      it "must call #http.powered_by_header with the path and the method: keyword argument" do
+        expect(subject.http).to receive(:powered_by_header).with(
+          path, method: request_method,
+        )
+
+        subject.http_powered_by_header(path, method: request_method)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:powered_by_header).with(
+            path, method: request_method
+          )
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting the 'X-Powered-By' header for #{request_method.upcase} #{url} ..."
+          )
+
+          subject.http_powered_by_header(path, method: request_method)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_response_body" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.response_body with :head and the path" do
+        expect(subject.http).to receive(:response_body).with(:get,path)
+
+        subject.http_response_body(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:response_body).with(
+            :get, path
+          )
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting response body for GET #{url} ..."
+          )
+
+          subject.http_response_body(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+
+    context "when given a request method and a path" do
+      let(:request_method) { :head  }
+      let(:path)           { '/foo' }
+
+      it "must call #http.response_body with request method and the path" do
+        expect(subject.http).to receive(:response_body).with(
+          request_method, path
+        )
+
+        subject.http_response_body(request_method,path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:response_body).with(
+            request_method, path
+          )
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting response body for #{request_method.upcase} #{url} ..."
+          )
+
+          subject.http_response_body(request_method,path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_copy" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.copy with the path" do
+        expect(subject.http).to receive(:copy).with(path)
+
+        subject.http_copy(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:copy).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting COPY #{url} ..."
+          )
+
+          subject.http_copy(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_delete" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.delete with the path" do
+        expect(subject.http).to receive(:delete).with(path)
+
+        subject.http_delete(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:delete).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting DELETE #{url} ..."
+          )
+
+          subject.http_delete(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_get" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.get with the path" do
+        expect(subject.http).to receive(:get).with(path)
+
+        subject.http_get(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:get).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting GET #{url} ..."
+          )
+
+          subject.http_get(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_get_headers" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.get_headers with the path" do
+        expect(subject.http).to receive(:get_headers).with(path)
+
+        subject.http_get_headers(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:get_headers).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting headers for GET #{url} ..."
+          )
+
+          subject.http_get_headers(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_get_cookies" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.get_cookies with the path" do
+        expect(subject.http).to receive(:get_cookies).with(path)
+
+        subject.http_get_cookies(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+          
+          allow(subject.http).to receive(:get_cookies).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Getting cookies for #{url} ..."
+          )
+
+          subject.http_get_cookies(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_get_body" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.get_body with the path" do
+        expect(subject.http).to receive(:get_body).with(path)
+
+        subject.http_get_body(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:get_body).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting body for GET #{url} ..."
+          )
+
+          subject.http_get_body(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_head" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.head with the path" do
+        expect(subject.http).to receive(:head).with(path)
+
+        subject.http_head(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:head).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting HEAD #{url} ..."
+          )
+
+          subject.http_head(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_lock" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.lock with the path" do
+        expect(subject.http).to receive(:lock).with(path)
+
+        subject.http_lock(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:lock).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting LOCK #{url} ..."
+          )
+
+          subject.http_lock(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_mkcol" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.mkcol with the path" do
+        expect(subject.http).to receive(:mkcol).with(path)
+
+        subject.http_mkcol(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:mkcol).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting MKCOL #{url} ..."
+          )
+
+          subject.http_mkcol(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_move" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.move with the path" do
+        expect(subject.http).to receive(:move).with(path)
+
+        subject.http_move(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:move).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting MOVE #{url} ..."
+          )
+
+          subject.http_move(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_options" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.options with the path" do
+        expect(subject.http).to receive(:options).with(path)
+
+        subject.http_options(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:options).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting OPTIONS #{url} ..."
+          )
+
+          subject.http_options(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_allowed_methods" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.allowed_methods with the path" do
+        expect(subject.http).to receive(:allowed_methods).with(path)
+
+        subject.http_allowed_methods(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:allowed_methods).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Checking allowed HTTP methods for #{url} ..."
+          )
+
+          subject.http_allowed_methods(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_patch" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.patch with the path" do
+        expect(subject.http).to receive(:patch).with(path)
+
+        subject.http_patch(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:patch).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting PATCH #{url} ..."
+          )
+
+          subject.http_patch(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_post" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.post with the path" do
+        expect(subject.http).to receive(:post).with(path)
+
+        subject.http_post(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:post).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting POST #{url} ..."
+          )
+
+          subject.http_post(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_post_headers" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.post_headers with the path" do
+        expect(subject.http).to receive(:post_headers).with(path)
+
+        subject.http_post_headers(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:post_headers).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting response headers for POST #{url} ..."
+          )
+
+          subject.http_post_headers(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_post_body" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.post_body with the path" do
+        expect(subject.http).to receive(:post_body).with(path)
+
+        subject.http_post_body(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:post_body).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting response body for POST #{url} ..."
+          )
+
+          subject.http_post_body(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_propfind" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.propfind with the path" do
+        expect(subject.http).to receive(:propfind).with(path)
+
+        subject.http_propfind(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:propfind).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting PROPFIND #{url} ..."
+          )
+
+          subject.http_propfind(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_proppatch" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.proppatch with the path" do
+        expect(subject.http).to receive(:proppatch).with(path)
+
+        subject.http_proppatch(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          expect(subject.http).to receive(:proppatch).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting PROPPATCH #{url} ..."
+          )
+
+          subject.http_proppatch(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_put" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.put with the path" do
+        expect(subject.http).to receive(:put).with(path)
+
+        subject.http_put(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:put).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting PUT #{url} ..."
+          )
+
+          subject.http_put(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_trace" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.trace with the path" do
+        expect(subject.http).to receive(:trace).with(path)
+
+        subject.http_trace(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:trace).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting TRACE #{url} ..."
+          )
+
+          subject.http_trace(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+
+  describe "#http_unlock" do
+    context "when given a path" do
+      let(:path) { '/foo' }
+
+      it "must call #http.unlock with the path" do
+        expect(subject.http).to receive(:unlock).with(path)
+
+        subject.http_unlock(path)
+      end
+
+      context "when debug messages are enabled" do
+        before { Ronin::Support::CLI::Printing.debug = true }
+
+        it "must print a debugging message" do
+          url = subject.url_for(path)
+
+          allow(subject.http).to receive(:unlock).with(path)
+
+          expect(subject).to receive(:print_debug).with(
+            "Requesting UNLOCK #{url} ..."
+          )
+
+          subject.http_unlock(path)
+        end
+
+        after { Ronin::Support::CLI::Printing.debug = false }
+      end
+    end
+  end
+end