tilia-dav 3.1.0.pre.alpha2

data/test/dav/partial_update/file_mock.rb

@@ -0,0 +1,92 @@
+module Tilia
+  module Dav
+    module PartialUpdate
+      class FileMock
+        include IPatchSupport
+
+        def initialize
+          @data = ''
+        end
+
+        def put(str)
+          if str.respond_to?(:read)
+            @data = str.read
+          else
+            @data = str
+          end
+        end
+
+        # Updates the file based on a range specification.
+        #
+        # The first argument is the data, which is either a readable stream
+        # resource or a string.
+        #
+        # The second argument is the type of update we're doing.
+        # This is either:
+        # * 1. append
+        # * 2. update based on a start byte
+        # * 3. update based on an end byte
+        #
+        # The third argument is the start or end byte.
+        #
+        # After a successful put operation, you may choose to return an ETag. The
+        # etag must always be surrounded by double-quotes. These quotes must
+        # appear in the actual string you're returning.
+        #
+        # Clients may use the ETag from a PUT request to later on make sure that
+        # when they update the file, the contents haven't changed in the mean
+        # time.
+        #
+        # @param resource|string data
+        # @param int range_type
+        # @param int offset
+        # @return string|null
+        def patch(data, range_type, offset = 0)
+          data = data.read if data.respond_to?(:read)
+
+          case range_type
+          when 1
+            @data += data
+          when 2, 3
+            # Turn the offset into an offset-offset.
+            offset = @data.length - offset if range_type == 3
+            @data[offset, data.length] = data
+          end
+          nil
+        end
+
+        def get
+          @data
+        end
+
+        def content_type
+          'text/plain'
+        end
+
+        def size
+          @data.length
+        end
+
+        def etag
+          "\"#{@data}\""
+        end
+
+        def delete
+          fail Exception::MethodNotAllowed
+        end
+
+        def name=(_name)
+          fail Exception::MethodNotAllowed
+        end
+
+        def name
+          'partial'
+        end
+
+        def last_modified
+          nil
+        end
+      end
+    end
+  end
+end

data/test/dav/partial_update/plugin_test.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module PartialUpdate
+      class PluginTest < DavServerTest
+        def setup
+          @node = FileMock.new
+          @tree = [@node]
+
+          super
+
+          @plugin = Plugin.new
+          @server.add_plugin(@plugin)
+        end
+
+        def test_init
+          assert_equal('partialupdate', @plugin.plugin_name)
+          assert_equal(['sabredav-partialupdate'], @plugin.features)
+          assert_equal(['PATCH'], @plugin.http_methods('partial'))
+          assert_equal([], @plugin.http_methods(''))
+        end
+
+        def test_patch_no_range
+          @node.put('aaaaaaaa')
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'PATCH',
+            'REQUEST_PATH'   => '/partial'
+          )
+          response = request(request)
+
+          assert_equal(400, response.status, "Full response body: #{response.body_as_string}")
+        end
+
+        def test_patch_not_supported
+          @node.put('aaaaaaaa')
+          request = Http::Request.new(
+            'PATCH',
+            '/',
+            'X-Update-Range' => '3-4'
+          )
+          request.body = 'bbb'
+          response = request(request)
+
+          assert_equal(405, response.status, "Full response body: #{response.body_as_string}")
+        end
+
+        def test_patch_no_content_type
+          @node.put('aaaaaaaa')
+          request = Http::Request.new(
+            'PATCH',
+            '/partial',
+            'X-Update-Range' => 'bytes=3-4'
+          )
+          request.body = 'bbb'
+          response = request(request)
+
+          assert_equal(415, response.status, "Full response body: #{response.body_as_string}")
+        end
+
+        def test_patch_bad_range
+          @node.put('aaaaaaaa')
+          request = Http::Request.new(
+            'PATCH',
+            '/partial',
+            'X-Update-Range' => 'bytes=3-4',
+            'Content-Type' => 'application/x-sabredav-partialupdate',
+            'Content-Length' => '3'
+          )
+          request.body = 'bbb'
+          response = request(request)
+
+          assert_equal(416, response.status, "Full response body: #{response.body_as_string}")
+        end
+
+        def test_patch_no_length
+          @node.put('aaaaaaaa')
+          request = Http::Request.new(
+            'PATCH',
+            '/partial',
+            'X-Update-Range' => 'bytes=3-5',
+            'Content-Type' => 'application/x-sabredav-partialupdate'
+          )
+          request.body = 'bbb'
+          response = request(request)
+
+          assert_equal(411, response.status, "Full response body: #{response.body_as_string}")
+        end
+
+        def test_patch_success
+          @node.put('aaaaaaaa')
+          request = Http::Request.new(
+            'PATCH',
+            '/partial',
+            'X-Update-Range' => 'bytes=3-5',
+            'Content-Type' => 'application/x-sabredav-partialupdate',
+            'Content-Length' => 3
+          )
+          request.body = 'bbb'
+          response = request(request)
+
+          assert_equal(204, response.status, "Full response body: #{response.body_as_string}")
+          assert_equal('aaabbbaa', @node.get)
+        end
+
+        def test_patch_no_end_range
+          @node.put('aaaaa')
+          request = Http::Request.new(
+            'PATCH',
+            '/partial',
+            'X-Update-Range' => 'bytes=3-',
+            'Content-Type' => 'application/x-sabredav-partialupdate',
+            'Content-Length' => '3'
+          )
+          request.body = 'bbb'
+
+          response = request(request)
+
+          assert_equal(204, response.status, "Full response body: #{response.body_as_string}")
+          assert_equal('aaabbb', @node.get)
+        end
+      end
+    end
+  end
+end

data/test/dav/partial_update/specification_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module PartialUpdate
+      # This test is an end-to-end sabredav test that goes through all
+      # the cases in the specification.
+      #
+      # See: http://sabre.io/dav/http-patch/
+      class SpecificationTest < Minitest::Test
+        def setup
+          @temp_dir = Dir.mktmpdir
+
+          @node = FsExt::File.new("#{@temp_dir}/foobar.txt")
+          @server = ServerMock.new([@node])
+          @server.debug_exceptions = true
+          @server.add_plugin(Plugin.new)
+
+          @node.put('1234567890')
+        end
+
+        def teardown
+          FileUtils.remove_entry @temp_dir
+        end
+
+        def test_update_range
+          data.each do |v|
+            (header_value, http_status, end_result, content_length) = v
+            content_length = 4 unless content_length
+
+            # RUBY: restore file
+            @node.put('1234567890')
+
+            headers = {
+              'Content-Type' => 'application/x-sabredav-partialupdate',
+              'X-Update-Range' => header_value
+            }
+
+            if content_length > 0
+              headers['Content-Length'] = content_length.to_s
+            end
+
+            request = Http::Request.new('PATCH', '/foobar.txt', headers, '----')
+
+            request.body = '----'
+            @server.http_request = request
+            @server.http_response = Http::ResponseMock.new
+            @server.sapi = Http::SapiMock.new
+            @server.exec
+
+            assert_equal(http_status, @server.http_response.status, "Incorrect http status received: #{@server.http_response.body}")
+            unless end_result.nil?
+              assert_equal(end_result, ::File.read("#{@temp_dir}/foobar.txt"))
+            end
+          end
+        end
+
+        def data
+          [
+            # Problems
+            ['foo',       400, nil],
+            ['bytes=0-3', 411, nil, 0],
+            ['bytes=4-1', 416, nil],
+
+            ['bytes=0-3', 204, '----567890'],
+            ['bytes=1-4', 204, '1----67890'],
+            ['bytes=0-',  204, '----567890'],
+            ['bytes=-4',  204, '123456----'],
+            ['bytes=-2',  204, '12345678----'],
+            ['bytes=2-',  204, '12----7890'],
+            ['append',    204, '1234567890----']
+          ]
+        end
+      end
+    end
+  end
+end

data/test/dav/prop_find_test.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class PropFindTest < Minitest::Test
+      def test_handle
+        prop_find = PropFind.new('foo', ['{DAV:}displayname'])
+        prop_find.handle('{DAV:}displayname', 'foobar')
+
+        assert_equal(
+          {
+            200 => { '{DAV:}displayname' => 'foobar' },
+            404 => {}
+          },
+          prop_find.result_for_multi_status
+        )
+      end
+
+      def test_handle_call_back
+        prop_find = PropFind.new('foo', ['{DAV:}displayname'])
+        prop_find.handle(
+          '{DAV:}displayname',
+          lambda do
+            return 'foobar'
+          end
+        )
+
+        assert_equal(
+          {
+            200 => { '{DAV:}displayname' => 'foobar' },
+            404 => {}
+          },
+          prop_find.result_for_multi_status
+        )
+      end
+
+      def test_all_prop_defaults
+        prop_find = PropFind.new('foo', ['{DAV:}displayname'], 0, PropFind::ALLPROPS)
+
+        assert_equal(
+          {
+            200 => {}
+          },
+          prop_find.result_for_multi_status
+        )
+      end
+
+      def test_set
+        prop_find = PropFind.new('foo', ['{DAV:}displayname'])
+        prop_find.set('{DAV:}displayname', 'bar')
+
+        assert_equal(
+          {
+            200 => { '{DAV:}displayname' => 'bar' },
+            404 => {}
+          },
+          prop_find.result_for_multi_status
+        )
+      end
+
+      def test_set_allprop_custom
+        prop_find = PropFind.new('foo', ['{DAV:}displayname'], 0, PropFind::ALLPROPS)
+        prop_find.set('{DAV:}customproperty', 'bar')
+
+        assert_equal(
+          {
+            200 => { '{DAV:}customproperty' => 'bar' }
+          },
+          prop_find.result_for_multi_status
+        )
+      end
+
+      def test_set_unset
+        prop_find = PropFind.new('foo', ['{DAV:}displayname'])
+        prop_find.set('{DAV:}displayname', 'bar')
+        prop_find.set('{DAV:}displayname', nil)
+
+        assert_equal(
+          {
+            200 => {},
+            404 =>  { '{DAV:}displayname' => nil }
+          }, prop_find.result_for_multi_status
+        )
+      end
+    end
+  end
+end

data/test/dav/prop_patch_test.rb

@@ -0,0 +1,367 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class PropPatchTest < Minitest::Test
+      def setup
+        @prop_patch = PropPatch.new(
+          '{DAV:}displayname' => 'foo'
+        )
+        assert_equal({ '{DAV:}displayname' => 'foo' }, @prop_patch.mutations)
+      end
+
+      def test_handle_single_success
+        has_ran = false
+
+        @prop_patch.handle(
+          '{DAV:}displayname',
+          lambda do |value|
+            has_ran = true
+            assert_equal('foo', value)
+            return true
+          end
+        )
+
+        assert(@prop_patch.commit)
+        result = @prop_patch.result
+        assert_equal({ '{DAV:}displayname' => 200 }, result)
+
+        assert(has_ran)
+      end
+
+      def test_handle_single_fail
+        has_ran = false
+
+        @prop_patch.handle(
+          '{DAV:}displayname',
+          lambda do |value|
+            has_ran = true
+            assert_equal('foo', value)
+            return false
+          end
+        )
+
+        refute(@prop_patch.commit)
+        result = @prop_patch.result
+        assert_equal({ '{DAV:}displayname' => 403 }, result)
+
+        assert(has_ran)
+      end
+
+      def test_handle_single_custom_result
+        has_ran = false
+
+        @prop_patch.handle(
+          '{DAV:}displayname',
+          lambda do |value|
+            has_ran = true
+            assert_equal('foo', value)
+            return 201
+          end
+        )
+
+        assert(@prop_patch.commit)
+        result = @prop_patch.result
+        assert_equal({ '{DAV:}displayname' => 201 }, result)
+
+        assert(has_ran)
+      end
+
+      def test_handle_single_delete_success
+        has_ran = false
+
+        @prop_patch = PropPatch.new('{DAV:}displayname' => nil)
+        @prop_patch.handle(
+          '{DAV:}displayname',
+          lambda do |value|
+            has_ran = true
+            assert_nil(value)
+            return true
+          end
+        )
+
+        assert(@prop_patch.commit)
+        result = @prop_patch.result
+        assert_equal({ '{DAV:}displayname' => 204 }, result)
+
+        assert(has_ran)
+      end
+
+      def test_handle_nothing
+        has_ran = false
+
+        @prop_patch.handle(
+          '{DAV:}foobar',
+          lambda do |_value|
+            has_ran = true
+          end
+        )
+
+        refute(has_ran)
+      end
+
+      def test_handle_remaining
+        has_ran = false
+
+        @prop_patch.handle_remaining(
+          lambda do |mutations|
+            has_ran = true
+            assert_equal({ '{DAV:}displayname' => 'foo' }, mutations)
+            return true
+          end
+        )
+
+        assert(@prop_patch.commit)
+        result = @prop_patch.result
+        assert_equal({ '{DAV:}displayname' => 200 }, result)
+
+        assert(has_ran)
+      end
+
+      def test_handle_remaining_nothing_to_do
+        has_ran = false
+
+        @prop_patch.handle('{DAV:}displayname', ->() {})
+        @prop_patch.handle_remaining(
+          lambda do |_mutations|
+            has_ran = true
+          end
+        )
+
+        refute(has_ran)
+      end
+
+      def test_update_result_code
+        @prop_patch.update_result_code('{DAV:}displayname', 201)
+        assert(@prop_patch.commit)
+        result = @prop_patch.result
+        assert_equal({ '{DAV:}displayname' => 201 }, result)
+      end
+
+      def test_update_result_code_fail
+        @prop_patch.update_result_code('{DAV:}displayname', 402)
+        refute(@prop_patch.commit)
+        result = @prop_patch.result
+        assert_equal({ '{DAV:}displayname' => 402 }, result)
+      end
+
+      def test_set_remaining_result_code
+        @prop_patch.remaining_result_code = 204
+        assert(@prop_patch.commit)
+        result = @prop_patch.result
+        assert_equal({ '{DAV:}displayname' => 204 }, result)
+      end
+
+      def test_commit_no_handler
+        refute(@prop_patch.commit)
+        result = @prop_patch.result
+        assert_equal({ '{DAV:}displayname' => 403 }, result)
+      end
+
+      def test_handler_not_called
+        has_ran = false
+
+        @prop_patch.update_result_code('{DAV:}displayname', 402)
+        @prop_patch.handle(
+          '{DAV:}displayname',
+          lambda do |_value|
+            has_ran = true
+          end
+        )
+
+        @prop_patch.commit
+
+        # The handler is not supposed to have ran
+        refute(has_ran)
+      end
+
+      def test_dependency_fail
+        prop_patch = PropPatch.new(
+          '{DAV:}a' => 'foo',
+          '{DAV:}b' => 'bar'
+        )
+
+        called_a = false
+        called_b = false
+
+        prop_patch.handle(
+          '{DAV:}a',
+          lambda do |_|
+            called_a = true
+            return false
+          end
+        )
+        prop_patch.handle(
+          '{DAV:}b',
+          lambda do |_|
+            called_b = true
+            return false
+          end
+        )
+
+        result = prop_patch.commit
+        assert(called_a)
+        refute(called_b)
+
+        refute(result)
+
+        assert_equal(
+          {
+            '{DAV:}a' => 403,
+            '{DAV:}b' => 424
+          },
+          prop_patch.result
+        )
+      end
+
+      # @expectedException \UnexpectedValueException
+      def test_handle_single_broken_result
+        prop_patch = PropPatch.new(
+          '{DAV:}a' => 'foo'
+        )
+
+        prop_patch.handle(
+          '{DAV:}a',
+          lambda do |_|
+            return []
+          end
+        )
+        assert_raises(RuntimeError) { prop_patch.commit }
+      end
+
+      def test_handle_multi_value_success
+        prop_patch = PropPatch.new(
+          '{DAV:}a' => 'foo',
+          '{DAV:}b' => 'bar',
+          '{DAV:}c' => nil
+        )
+
+        called_a = false
+
+        prop_patch.handle(
+          ['{DAV:}a', '{DAV:}b', '{DAV:}c'],
+          lambda do |properties|
+            called_a = true
+            assert_equal(
+              {
+                '{DAV:}a' => 'foo',
+                '{DAV:}b' => 'bar',
+                '{DAV:}c' => nil
+              },
+              properties
+            )
+            return true
+          end
+        )
+        result = prop_patch.commit
+        assert(called_a)
+        assert(result)
+
+        assert_equal(
+          {
+            '{DAV:}a' => 200,
+            '{DAV:}b' => 200,
+            '{DAV:}c' => 204
+          },
+          prop_patch.result
+        )
+      end
+
+      def test_handle_multi_value_fail
+        prop_patch = PropPatch.new(
+          '{DAV:}a' => 'foo',
+          '{DAV:}b' => 'bar',
+          '{DAV:}c' => nil
+        )
+
+        called_a = false
+
+        prop_patch.handle(
+          ['{DAV:}a', '{DAV:}b', '{DAV:}c'],
+          lambda do |properties|
+            called_a = true
+            assert_equal(
+              {
+                '{DAV:}a' => 'foo',
+                '{DAV:}b' => 'bar',
+                '{DAV:}c' => nil
+              },
+              properties
+            )
+            return false
+          end
+        )
+        result = prop_patch.commit
+        assert(called_a)
+        refute(result)
+
+        assert_equal(
+          {
+            '{DAV:}a' => 403,
+            '{DAV:}b' => 403,
+            '{DAV:}c' => 403
+          },
+          prop_patch.result
+        )
+      end
+
+      def test_handle_multi_value_custom_result
+        prop_patch = PropPatch.new(
+          '{DAV:}a' => 'foo',
+          '{DAV:}b' => 'bar',
+          '{DAV:}c' => nil
+        )
+
+        called_a = false
+
+        prop_patch.handle(
+          ['{DAV:}a', '{DAV:}b', '{DAV:}c'],
+          lambda do |properties|
+            called_a = true
+            assert_equal(
+              {
+                '{DAV:}a' => 'foo',
+                '{DAV:}b' => 'bar',
+                '{DAV:}c' => nil
+              },
+              properties
+            )
+
+            return {
+              '{DAV:}a' => 201,
+              '{DAV:}b' => 204
+            }
+          end
+        )
+        result = prop_patch.commit
+        assert(called_a)
+        refute(result)
+
+        assert_equal(
+          {
+            '{DAV:}a' => 201,
+            '{DAV:}b' => 204,
+            '{DAV:}c' => 500
+          },
+          prop_patch.result
+        )
+      end
+
+      def test_handle_multi_value_broken
+        prop_patch = PropPatch.new(
+          '{DAV:}a' => 'foo',
+          '{DAV:}b' => 'bar',
+          '{DAV:}c' => nil
+        )
+
+        prop_patch.handle(
+          ['{DAV:}a', '{DAV:}b', '{DAV:}c'],
+          lambda do |_properties|
+            return 'hi'
+          end
+        )
+        assert_raises(RuntimeError) { prop_patch.commit }
+      end
+    end
+  end
+end