webdav.rb 0.2.1

data/lib/webdav.rb

@@ -0,0 +1,157 @@
+# WebDAV.rb
+# WebDAV
+
+gem 'http.rb'; require 'http.rb'
+require 'net/http'
+require 'uri'
+
+require_relative './Net/HTTP/Report'
+require_relative './String/to_const'
+require_relative './WebDAV/Error'
+require_relative './WebDAV/MultiStatus'
+require_relative './WebDAV/Response'
+
+class WebDAV
+
+  # Properties
+
+  def propfind(path = '/', body: nil, depth: '1')
+    response = request(:propfind, path, body: body, headers: {'Depth' => depth})
+    handle_response(response)
+  end
+
+  def proppatch(path, body:)
+    response = request(:proppatch, path, body: body)
+    handle_response(response)
+  end
+
+  # Versioning
+
+  def report(path, body:, depth: '1')
+    response = request(:report, path, body: body, headers: {'Depth' => depth})
+    handle_response(response)
+  end
+
+  # Collections
+
+  def mkcol(path)
+    response = request(:mkcol, path)
+    handle_response(response)
+  end
+
+  # Namespace
+
+  def copy(path, to:, depth: 'infinity', overwrite: true)
+    response = request(:copy, path, headers: {
+      'Destination' => resolve_uri(to).to_s,
+      'Depth' => depth,
+      'Overwrite' => overwrite ? 'T' : 'F'
+    })
+    handle_response(response)
+  end
+
+  def move(path, to:, overwrite: true)
+    response = request(:move, path, headers: {
+      'Destination' => resolve_uri(to).to_s,
+      'Overwrite' => overwrite ? 'T' : 'F'
+    })
+    handle_response(response)
+  end
+
+  # Locking
+
+  def lock(path, body:)
+    response = request(:lock, path, body: body)
+    handle_response(response)
+  end
+
+  def unlock(path, token:)
+    response = request(:unlock, path, headers: {'Lock-Token' => "<#{token}>"})
+    handle_response(response)
+  end
+
+  # Standard HTTP
+
+  def get(path)
+    response = request(:get, path)
+    handle_response(response)
+  end
+
+  def head(path)
+    response = request(:head, path)
+    handle_response(response)
+  end
+
+  def post(path, body:, content_type: 'application/xml')
+    response = request(:post, path, body: body, headers: {'Content-Type' => content_type})
+    handle_response(response)
+  end
+
+  def put(path, body:, content_type: 'application/octet-stream')
+    response = request(:put, path, body: body, headers: {'Content-Type' => content_type})
+    handle_response(response)
+  end
+
+  def patch(path, body:, content_type: 'application/xml')
+    response = request(:patch, path, body: body, headers: {'Content-Type' => content_type})
+    handle_response(response)
+  end
+
+  def delete(path)
+    response = request(:delete, path)
+    handle_response(response)
+  end
+
+  def options(path = '/')
+    response = request(:options, path)
+    handle_response(response)
+  end
+
+  def trace(path)
+    response = request(:trace, path)
+    handle_response(response)
+  end
+
+  private
+
+  def initialize(uri, username:, password:)
+    @uri = uri.is_a?(URI) ? uri : URI.parse(uri)
+    @username = username
+    @password = password
+  end
+
+  def resolve_uri(path)
+    URI.join(@uri, path)
+  end
+
+  def request_uri(path)
+    resolve_uri(path).request_uri
+  end
+
+  def default_headers
+    {'Content-Type' => 'application/xml; charset=utf-8'}
+  end
+
+  def request_class(verb)
+    "Net::HTTP::#{verb.to_s.capitalize}".to_const
+  end
+
+  def request(verb, path, body: nil, headers: {})
+    request_object = request_class(verb).new(request_uri(path))
+    request_object.basic_auth(@username, @password)
+    request_object.body = body if body
+    merged_headers = default_headers.merge(headers)
+    merged_headers.each{|k, v| request_object[k] = v}
+    HTTP.request(resolve_uri(path), request_object)
+  end
+
+  def handle_response(response)
+    raise WebDAV::Error.new(response) if response.code.to_i >= 400
+    case response.code.to_i
+    when 207
+      MultiStatus.new(response)
+    else
+      Response.new(response)
+    end
+  end
+end

data/test/Net/HTTP/Report_test.rb

@@ -0,0 +1,21 @@
+# test/Net/HTTP/Report_test.rb
+
+require_relative '../../helper'
+
+describe Net::HTTP::Report do
+  it "is a subclass of Net::HTTPRequest" do
+    _(Net::HTTP::Report < Net::HTTPRequest).must_equal(true)
+  end
+
+  it "has the correct METHOD" do
+    _(Net::HTTP::Report::METHOD).must_equal('REPORT')
+  end
+
+  it "accepts a body" do
+    _(Net::HTTP::Report::REQUEST_HAS_BODY).must_equal(true)
+  end
+
+  it "expects a response body" do
+    _(Net::HTTP::Report::RESPONSE_HAS_BODY).must_equal(true)
+  end
+end

data/test/WebDAV/Error_test.rb

@@ -0,0 +1,85 @@
+# test/WebDAV/Error_test.rb
+
+require_relative '../helper'
+
+describe WebDAV::Error do
+  let(:mock_response) do
+    MockResponse.new(
+      code: '404',
+      message: 'Not Found',
+      body: '<!DOCTYPE html><html><body>Not Found</body></html>'
+    )
+  end
+
+  let(:error){WebDAV::Error.new(mock_response)}
+
+  describe "#code" do
+    it "returns the status code as an integer" do
+      _(error.code).must_equal 404
+    end
+  end
+
+  describe "#message" do
+    it "returns the status message" do
+      _(error.message).must_equal 'Not Found'
+    end
+  end
+
+  describe "#body" do
+    it "returns the response body" do
+      _(error.body).must_include 'Not Found'
+    end
+  end
+
+  describe "#to_s" do
+    it "includes the status code and message" do
+      _(error.to_s).must_equal 'HTTP 404: Not Found'
+    end
+  end
+
+  describe "inheritance" do
+    it "is a StandardError" do
+      _(error).must_be_kind_of StandardError
+    end
+
+    it "can be raised and rescued" do
+      assert_raises(WebDAV::Error) do
+        raise WebDAV::Error.new(mock_response)
+      end
+    end
+  end
+
+  describe "with a 401 status code" do
+    let(:mock_response) do
+      MockResponse.new(
+        code: '401',
+        message: 'Unauthorized',
+        body: ''
+      )
+    end
+
+    let(:error){WebDAV::Error.new(mock_response)}
+
+    it "handles a 401 error" do
+      _(error.code).must_equal 401
+      _(error.to_s).must_equal 'HTTP 401: Unauthorized'
+    end
+  end
+
+  describe "with a 500 status code" do
+    let(:mock_response) do
+      MockResponse.new(
+        code: '500',
+        message: 'Internal Server Error',
+        body: ''
+      )
+    end
+
+    let(:error){WebDAV::Error.new(mock_response)}
+
+    it "handles a 500 error" do
+      _(error.code).must_equal 500
+      _(error.to_s).must_equal 'HTTP 500: Internal Server Error'
+    end
+  end
+end

data/test/WebDAV/MultiStatus_test.rb

@@ -0,0 +1,231 @@
+# test/WebDAV/MultiStatus_test.rb
+
+require_relative '../helper'
+
+describe WebDAV::MultiStatus do
+  let(:multistatus_xml) do
+    <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <d:multistatus xmlns:d="DAV:">
+        <d:response>
+          <d:href>/dav/calendars/user/test/calendar1/</d:href>
+          <d:propstat>
+            <d:prop>
+              <d:displayname>Work</d:displayname>
+              <d:resourcetype><d:collection/></d:resourcetype>
+            </d:prop>
+            <d:status>HTTP/1.1 200 OK</d:status>
+          </d:propstat>
+        </d:response>
+        <d:response>
+          <d:href>/dav/calendars/user/test/calendar2/</d:href>
+          <d:propstat>
+            <d:prop>
+              <d:displayname>Personal</d:displayname>
+              <d:resourcetype><d:collection/></d:resourcetype>
+            </d:prop>
+            <d:status>HTTP/1.1 200 OK</d:status>
+          </d:propstat>
+        </d:response>
+      </d:multistatus>
+    XML
+  end
+
+  let(:mock_response) do
+    MockResponse.new(
+      code: '207',
+      message: 'Multi-Status',
+      body: multistatus_xml
+    )
+  end
+
+  let(:response){WebDAV::MultiStatus.new(mock_response)}
+
+  describe "#code" do
+    it "returns 207" do
+      _(response.code).must_equal 207
+    end
+  end
+
+  describe "#success?" do
+    it "returns true" do
+      _(response.success?).must_equal true
+    end
+  end
+
+  describe "#resources" do
+    it "returns an array" do
+      _(response.resources).must_be_kind_of Array
+    end
+
+    it "parses the correct number of resources" do
+      _(response.resources.length).must_equal 2
+    end
+
+    it "extracts href from each resource" do
+      _(response.resources[0][:href]).must_equal '/dav/calendars/user/test/calendar1/'
+      _(response.resources[1][:href]).must_equal '/dav/calendars/user/test/calendar2/'
+    end
+
+    it "extracts properties from each propstat, keyed by namespace then local name" do
+      _(response.resources[0][:propstats][0][:properties]['DAV:']['displayname']).must_equal 'Work'
+      _(response.resources[1][:propstats][0][:properties]['DAV:']['displayname']).must_equal 'Personal'
+    end
+
+    it "extracts per-propstat status" do
+      _(response.resources[0][:propstats][0][:status]).must_equal 'HTTP/1.1 200 OK'
+    end
+
+    it "leaves response-level status nil when propstats are present" do
+      _(response.resources[0][:status]).must_be_nil
+    end
+  end
+
+  describe "with multiple propstats per response" do
+    let(:mixed_status_xml) do
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <d:multistatus xmlns:d="DAV:">
+          <d:response>
+            <d:href>/calendar/</d:href>
+            <d:propstat>
+              <d:prop>
+                <d:displayname>Work</d:displayname>
+              </d:prop>
+              <d:status>HTTP/1.1 200 OK</d:status>
+            </d:propstat>
+            <d:propstat>
+              <d:prop>
+                <d:getctag/>
+              </d:prop>
+              <d:status>HTTP/1.1 404 Not Found</d:status>
+            </d:propstat>
+          </d:response>
+        </d:multistatus>
+      XML
+    end
+
+    let(:mixed_response){WebDAV::MultiStatus.new(MockResponse.new(code: '207', message: 'Multi-Status', body: mixed_status_xml))}
+
+    it "preserves each propstat as a separate entry" do
+      _(mixed_response.resources[0][:propstats].length).must_equal 2
+    end
+
+    it "keeps the 200 propstat's properties under its own status" do
+      successful_propstat = mixed_response.resources[0][:propstats][0]
+      _(successful_propstat[:status]).must_equal 'HTTP/1.1 200 OK'
+      _(successful_propstat[:properties]['DAV:']['displayname']).must_equal 'Work'
+    end
+
+    it "keeps the 404 propstat's properties under its own status" do
+      missing_propstat = mixed_response.resources[0][:propstats][1]
+      _(missing_propstat[:status]).must_equal 'HTTP/1.1 404 Not Found'
+      _(missing_propstat[:properties]['DAV:']).must_include 'getctag'
+    end
+  end
+
+  describe "with response-level status (COPY/MOVE/DELETE)" do
+    let(:response_level_xml) do
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <d:multistatus xmlns:d="DAV:">
+          <d:response>
+            <d:href>/dir/file.txt</d:href>
+            <d:status>HTTP/1.1 403 Forbidden</d:status>
+          </d:response>
+        </d:multistatus>
+      XML
+    end
+
+    let(:response_level_response){WebDAV::MultiStatus.new(MockResponse.new(code: '207', message: 'Multi-Status', body: response_level_xml))}
+
+    it "populates the response-level status" do
+      _(response_level_response.resources[0][:status]).must_equal 'HTTP/1.1 403 Forbidden'
+    end
+
+    it "leaves propstats empty" do
+      _(response_level_response.resources[0][:propstats]).must_equal []
+    end
+  end
+
+  describe "with multiple namespaces" do
+    let(:multi_namespace_xml) do
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <d:multistatus xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav">
+          <d:response>
+            <d:href>/calendar/event.ics</d:href>
+            <d:propstat>
+              <d:prop>
+                <d:getetag>"abc123"</d:getetag>
+                <c:calendar-data>BEGIN:VCALENDAR</c:calendar-data>
+              </d:prop>
+              <d:status>HTTP/1.1 200 OK</d:status>
+            </d:propstat>
+          </d:response>
+        </d:multistatus>
+      XML
+    end
+
+    let(:multi_namespace_response){WebDAV::MultiStatus.new(MockResponse.new(code: '207', message: 'Multi-Status', body: multi_namespace_xml))}
+
+    it "groups DAV properties under the DAV: namespace" do
+      _(multi_namespace_response.resources[0][:propstats][0][:properties]['DAV:']['getetag']).must_equal '"abc123"'
+    end
+
+    it "groups CalDAV properties under the CalDAV namespace" do
+      _(multi_namespace_response.resources[0][:propstats][0][:properties]['urn:ietf:params:xml:ns:caldav']['calendar-data']).must_equal 'BEGIN:VCALENDAR'
+    end
+  end
+
+  describe "with the same local name in different namespaces" do
+    let(:collision_xml) do
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <d:multistatus xmlns:d="DAV:" xmlns:x="http://example.com/custom">
+          <d:response>
+            <d:href>/file.txt</d:href>
+            <d:propstat>
+              <d:prop>
+                <d:displayname>From DAV</d:displayname>
+                <x:displayname>From custom</x:displayname>
+              </d:prop>
+              <d:status>HTTP/1.1 200 OK</d:status>
+            </d:propstat>
+          </d:response>
+        </d:multistatus>
+      XML
+    end
+
+    let(:collision_response){WebDAV::MultiStatus.new(MockResponse.new(code: '207', message: 'Multi-Status', body: collision_xml))}
+
+    it "keeps both without collision" do
+      properties = collision_response.resources[0][:propstats][0][:properties]
+      _(properties['DAV:']['displayname']).must_equal 'From DAV'
+      _(properties['http://example.com/custom']['displayname']).must_equal 'From custom'
+    end
+  end
+
+  describe "with empty multistatus" do
+    let(:empty_xml) do
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <d:multistatus xmlns:d="DAV:">
+        </d:multistatus>
+      XML
+    end
+
+    let(:empty_response) do
+      MockResponse.new(
+        code: '207',
+        message: 'Multi-Status',
+        body: empty_xml
+      )
+    end
+
+    it "returns an empty array" do
+      r = WebDAV::MultiStatus.new(empty_response)
+      _(r.resources).must_equal []
+    end
+  end
+end

data/test/WebDAV/Response_test.rb

@@ -0,0 +1,72 @@
+# test/WebDAV/Response_test.rb
+
+require_relative '../helper'
+
+describe WebDAV::Response do
+  let(:mock_response) do
+    headers = {'ETag' => '"abc123"', 'Content-Type' => 'text/html'}
+    response = MockResponse.new(
+      code: '200',
+      message: 'OK',
+      body: '<html>Hello</html>',
+      headers_hash: headers
+    )
+    response
+  end
+
+  let(:response){WebDAV::Response.new(mock_response)}
+
+  describe "#code" do
+    it "returns the status code as an integer" do
+      _(response.code).must_equal 200
+    end
+  end
+
+  describe "#message" do
+    it "returns the status message" do
+      _(response.message).must_equal 'OK'
+    end
+  end
+
+  describe "#body" do
+    it "returns the response body" do
+      _(response.body).must_equal '<html>Hello</html>'
+    end
+  end
+
+  describe "#success?" do
+    it "returns true for 2xx responses" do
+      _(response.success?).must_equal true
+    end
+
+    it "returns false for 3xx responses" do
+      redirect_response = MockResponse.new(code: '302', message: 'Found', body: '')
+      r = WebDAV::Response.new(redirect_response)
+      _(r.success?).must_equal false
+    end
+
+    it "returns false for 4xx responses" do
+      error_response = MockResponse.new(code: '404', message: 'Not Found', body: '')
+      r = WebDAV::Response.new(error_response)
+      _(r.success?).must_equal false
+    end
+
+    it "returns false for 5xx responses" do
+      error_response = MockResponse.new(code: '500', message: 'Internal Server Error', body: '')
+      r = WebDAV::Response.new(error_response)
+      _(r.success?).must_equal false
+    end
+  end
+
+  describe "#etag" do
+    it "returns the ETag header" do
+      _(response.etag).must_equal '"abc123"'
+    end
+  end
+
+  describe "#content_type" do
+    it "returns the Content-Type header" do
+      _(response.content_type).must_equal 'text/html'
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,13 @@
+# test/helper.rb
+
+require 'minitest/autorun'
+require 'minitest/mock'
+require 'minitest/spec'
+
+require_relative '../lib/webdav'
+
+MockResponse = Struct.new(:code, :message, :body, :headers_hash, keyword_init: true) do
+  def [](key)
+    headers_hash&.dig(key)
+  end
+end