tilia-dav 3.1.0.pre.alpha2

data/test/dav/browser/prop_find_all_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Browser
+      class PropFindAllTest < Minitest::Test
+        def test_handle_simple
+          pf = PropFindAll.new('foo')
+          pf.handle('{DAV:}displayname', 'foo')
+
+          assert_equal(200, pf.status('{DAV:}displayname'))
+          assert_equal('foo', pf.get('{DAV:}displayname'))
+        end
+
+        def test_handle_call_back
+          pf = PropFindAll.new('foo')
+          pf.handle('{DAV:}displayname', ->() { return 'foo'; })
+
+          assert_equal(200, pf.status('{DAV:}displayname'))
+          assert_equal('foo', pf.get('{DAV:}displayname'))
+        end
+
+        def test_set
+          pf = PropFindAll.new('foo')
+          pf.set('{DAV:}displayname', 'foo')
+
+          assert_equal(200, pf.status('{DAV:}displayname'))
+          assert_equal('foo', pf.get('{DAV:}displayname'))
+        end
+
+        def test_set_null
+          pf = PropFindAll.new('foo')
+          pf.set('{DAV:}displayname', nil)
+
+          assert_equal(404, pf.status('{DAV:}displayname'))
+          assert_equal(nil, pf.get('{DAV:}displayname'))
+        end
+
+        def test_get404_properties
+          pf = PropFindAll.new('foo')
+          pf.set('{DAV:}displayname', nil)
+          assert_equal(
+            ['{DAV:}displayname'],
+            pf.get404_properties
+          )
+        end
+
+        def test_get404_properties_nothing
+          pf = PropFindAll.new('foo')
+          pf.set('{DAV:}displayname', 'foo')
+          assert_equal(
+            ['{http://sabredav.org/ns}idk'],
+            pf.get404_properties
+          )
+        end
+      end
+    end
+  end
+end

data/test/dav/client_mock.rb

@@ -0,0 +1,24 @@
+module Tilia
+  module Dav
+    class ClientMock < Client
+      attr_accessor :request
+      attr_accessor :response
+
+      attr_accessor :url
+      attr_accessor :curl_settings
+
+      # Just making this method public
+      #
+      # @param string url
+      # @return string
+      def absolute_url(url)
+        super
+      end
+
+      def do_request(request)
+        @request = request
+        @response
+      end
+    end
+  end
+end

data/test/dav/client_test.rb

@@ -0,0 +1,231 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class ClientTest < Minitest::Test
+      def test_construct
+        client = ClientMock.new(
+          'baseUri' => '/'
+        )
+        assert_kind_of(ClientMock, client)
+      end
+
+      def test_construct_no_base_uri
+        assert_raises(ArgumentError) do
+          client = ClientMock.new({})
+        end
+      end
+
+      def test_auth
+        client = ClientMock.new(
+          'baseUri' => '/',
+          'userName' => 'foo',
+          'password' => 'bar'
+        )
+
+        assert_equal('foo:bar', client.curl_settings[:userpwd])
+        assert_equal([:basic, :digest], client.curl_settings[:httpauth])
+      end
+
+      def test_basic_auth
+        client = ClientMock.new(
+          'baseUri' => '/',
+          'userName' => 'foo',
+          'password' => 'bar',
+          'authType' => Client::AUTH_BASIC
+        )
+
+        assert_equal('foo:bar', client.curl_settings[:userpwd])
+        assert_equal([:basic], client.curl_settings[:httpauth])
+      end
+
+      def test_digest_auth
+        client = ClientMock.new(
+          'baseUri' => '/',
+          'userName' => 'foo',
+          'password' => 'bar',
+          'authType' => Client::AUTH_DIGEST
+        )
+
+        assert_equal('foo:bar', client.curl_settings[:userpwd])
+        assert_equal([:digest], client.curl_settings[:httpauth])
+      end
+
+      def test_ntlm_auth
+        client = ClientMock.new(
+          'baseUri' => '/',
+          'userName' => 'foo',
+          'password' => 'bar',
+          'authType' => Client::AUTH_NTLM
+        )
+
+        assert_equal('foo:bar', client.curl_settings[:userpwd])
+        assert_equal([:ntlm], client.curl_settings[:httpauth])
+      end
+
+      def test_proxy
+        client = ClientMock.new(
+          'baseUri' => '/',
+          'proxy' => 'localhost:8888'
+        )
+
+        assert_equal('localhost:8888', client.curl_settings[:proxy])
+      end
+
+      def test_encoding
+        client = ClientMock.new(
+          'baseUri' => '/',
+          'encoding' => Client::ENCODING_IDENTITY | Client::ENCODING_GZIP | Client::ENCODING_DEFLATE
+        )
+
+        assert_equal('identity,deflate,gzip', client.curl_settings[:encoding])
+      end
+
+      def test_prop_find
+        client = ClientMock.new(
+          'baseUri' => '/'
+        )
+
+        response_body = <<XML
+<?xml version="1.0"?>
+<multistatus xmlns="DAV:">
+  <response>
+    <href>/foo</href>
+    <propstat>
+      <prop>
+        <displayname>bar</displayname>
+      </prop>
+      <status>HTTP/1.1 200 OK</status>
+    </propstat>
+  </response>
+</multistatus>
+XML
+
+        client.response = Http::Response.new(207, {}, response_body)
+        result = client.prop_find('foo', ['{DAV:}displayname', '{urn:zim}gir'])
+
+        assert_equal({ '{DAV:}displayname' => 'bar' }, result)
+
+        request = client.request
+        assert_equal('PROPFIND', request.method)
+        assert_equal('/foo', request.url)
+        assert_equal(
+          {
+            'Depth' => [0],
+            'Content-Type' => ['application/xml']
+          },
+          request.headers
+        )
+      end
+
+      def test_prop_find_error
+        client = ClientMock.new(
+          'baseUri' => '/'
+        )
+
+        client.response = Http::Response.new(405, {})
+        assert_raises(Exception) do
+          client.prop_find('foo', ['{DAV:}displayname', '{urn:zim}gir'])
+        end
+      end
+
+      def test_prop_find_depth1
+        client = ClientMock.new(
+          'baseUri' => '/'
+        )
+
+        response_body = <<XML
+<?xml version="1.0"?>
+<multistatus xmlns="DAV:">
+  <response>
+    <href>/foo</href>
+    <propstat>
+      <prop>
+        <displayname>bar</displayname>
+      </prop>
+      <status>HTTP/1.1 200 OK</status>
+    </propstat>
+  </response>
+</multistatus>
+XML
+
+        client.response = Http::Response.new(207, {}, response_body)
+        result = client.prop_find('foo', ['{DAV:}displayname', '{urn:zim}gir'], 1)
+
+        assert_equal(
+          {
+            '/foo' => {
+              '{DAV:}displayname' => 'bar'
+            }
+          },
+          result
+        )
+
+        request = client.request
+        assert_equal('PROPFIND', request.method)
+        assert_equal('/foo', request.url)
+        assert_equal(
+          {
+            'Depth' => [1],
+            'Content-Type' => ['application/xml']
+          },
+          request.headers
+        )
+      end
+
+      def test_prop_patch
+        client = ClientMock.new(
+          'baseUri' => '/'
+        )
+
+        response_body = <<XML
+<?xml version="1.0"?>
+<multistatus xmlns="DAV:">
+  <response>
+    <href>/foo</href>
+    <propstat>
+      <prop>
+        <displayname>bar</displayname>
+      </prop>
+      <status>HTTP/1.1 200 OK</status>
+    </propstat>
+  </response>
+</multistatus>
+XML
+
+        client.response = Http::Response.new(207, {}, response_body)
+        result = client.prop_patch('foo', '{DAV:}displayname' => 'hi', '{urn:zim}gir' => nil)
+        request = client.request
+        assert_equal('PROPPATCH', request.method)
+        assert_equal('/foo', request.url)
+        assert_equal(
+          {
+            'Content-Type' => ['application/xml']
+          },
+          request.headers
+        )
+      end
+
+      def test_options
+        client = ClientMock.new(
+          'baseUri' => '/'
+        )
+
+        client.response = Http::Response.new(207,
+                                             'DAV' => 'calendar-access, extended-mkcol'
+                                            )
+        result = client.options
+
+        assert_equal(
+          ['calendar-access', 'extended-mkcol'],
+          result
+        )
+
+        request = client.request
+        assert_equal('OPTIONS', request.method)
+        assert_equal('/', request.url)
+        assert_equal({}, request.headers)
+      end
+    end
+  end
+end

data/test/dav/copy_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class BasicNodeTest < Minitest::Test
+      def setup
+        @temp_dir = Dir.mktmpdir
+      end
+
+      def teardown
+        FileUtils.remove_entry @temp_dir
+      end
+
+      # This test makes sure that a path like /foo cannot be copied into a path
+      # like /foo/bar/
+      def test_copy_into_sub_path
+        dir = Fs::Directory.new(@temp_dir)
+        server = ServerMock.new(dir)
+
+        dir.create_directory('foo')
+
+        request = Http::Request.new(
+          'COPY',
+          '/foo',
+          'Destination' => '/foo/bar'
+        )
+        response = Http::ResponseMock.new
+
+        assert_raises(Exception::Conflict) { server.invoke_method(request, response) }
+      end
+    end
+  end
+end

data/test/dav/exception/locked_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class Exception
+      class LockedTest < Minitest::Test
+        def test_serialize
+          dom = LibXML::XML::Document.new
+          root = LibXML::XML::Node.new('d:root')
+          LibXML::XML::Namespace.new(root, 'd', 'DAV:')
+          dom.root = root
+
+          lock_info = Locks::LockInfo.new
+          lock_info.uri = '/foo'
+          locked = Locked.new(lock_info)
+
+          locked.serialize(ServerMock.new, root)
+
+          output = dom.to_s
+
+          expected = <<XML
+<?xml version="1.0" encoding="UTF-8"?>
+<d:root xmlns:d="DAV:">
+  <d:lock-token-submitted>
+    <d:href>/foo</d:href>
+  </d:lock-token-submitted>
+</d:root>
+XML
+
+          assert_xml_equal(expected, output)
+        end
+
+        def test_serialize_ampersand
+          dom = LibXML::XML::Document.new
+          root = LibXML::XML::Node.new('d:root')
+          LibXML::XML::Namespace.new(root, 'd', 'DAV:')
+          dom.root = root
+
+          lock_info = Locks::LockInfo.new
+          lock_info.uri = '/foo&bar'
+          locked = Locked.new(lock_info)
+
+          locked.serialize(ServerMock.new, root)
+
+          output = dom.to_s
+
+          expected = <<XML
+<?xml version="1.0" encoding="UTF-8"?>
+<d:root xmlns:d="DAV:">
+  <d:lock-token-submitted>
+    <d:href>/foo&amp;bar</d:href>
+  </d:lock-token-submitted>
+</d:root>
+XML
+
+          assert_xml_equal(expected, output)
+        end
+      end
+    end
+  end
+end

data/test/dav/exception/payment_required_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class Exception
+      class PaymentRequiredTest < Minitest::Test
+        def test_get_http_code
+          ex = PaymentRequired.new
+          assert_equal(402, ex.http_code)
+        end
+      end
+    end
+  end
+end

data/test/dav/exception/service_unavailable_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class Exception
+      class ServiceUnavailableTest < Minitest::Test
+        def test_get_http_code
+          ex = ServiceUnavailable.new
+          assert_equal(503, ex.http_code)
+        end
+      end
+    end
+  end
+end

data/test/dav/exception/too_many_matches_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class Exception
+      class TooManyMatchesTest < Minitest::Test
+        def test_serialize
+          dom = LibXML::XML::Document.new
+          root = LibXML::XML::Node.new('d:root')
+          LibXML::XML::Namespace.new(root, 'd', 'DAV:')
+          dom.root = root
+
+          locked = TooManyMatches.new
+
+          locked.serialize(ServerMock.new, root)
+
+          output = dom.to_s
+
+          expected = <<XML
+<?xml version="1.0" encoding="UTF-8"?>
+<d:root xmlns:d="DAV:">
+  <d:number-of-matches-within-limits/>
+</d:root>
+XML
+
+          assert_xml_equal(expected, output)
+        end
+      end
+    end
+  end
+end