tilia-dav 3.1.0.pre.alpha2

data/test/dav/server_update_properties_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class ServerUpdatePropertiesTest < Minitest::Test
+      def setup
+        tree = [Tilia::Dav::SimpleCollection.new('foo')]
+        @server = Tilia::Dav::ServerMock.new(tree)
+      end
+
+      def test_update_properties_fail
+        result = @server.update_properties(
+          'foo',
+          '{DAV:}foo' => 'bar'
+        )
+
+        expected = { '{DAV:}foo' => 403 }
+        assert_equal(expected, result)
+      end
+
+      def test_update_properties_protected
+        @server.on(
+          'propPatch',
+          lambda do |_path, prop_patch|
+            prop_patch.handle_remaining(-> { true })
+          end
+        )
+        result = @server.update_properties(
+          'foo',
+          '{DAV:}getetag' => 'bla',
+          '{DAV:}foo' => 'bar'
+        )
+
+        expected = {
+          '{DAV:}getetag' => 403,
+          '{DAV:}foo' => 424
+        }
+        assert_equal(expected, result)
+      end
+
+      def test_update_properties_event_fail
+        @server.on(
+          'propPatch',
+          lambda do |_path, prop_patch|
+            prop_patch.update_result_code('{DAV:}foo', 404)
+            prop_patch.handle_remaining(-> { true })
+          end
+        )
+
+        result = @server.update_properties(
+          'foo',
+          '{DAV:}foo' => 'bar',
+          '{DAV:}foo2' => 'bla'
+        )
+
+        expected = {
+          '{DAV:}foo' => 404,
+          '{DAV:}foo2' => 424
+        }
+        assert_equal(expected, result)
+      end
+
+      def test_update_properties_event_success
+        @server.on(
+          'propPatch',
+          lambda do |_path, prop_patch|
+            prop_patch.handle(
+              ['{DAV:}foo', '{DAV:}foo2'],
+              lambda do |_|
+                return {
+                  '{DAV:}foo' => 200,
+                  '{DAV:}foo2' => 201
+                }
+              end
+            )
+          end
+        )
+
+        result = @server.update_properties(
+          'foo',
+          '{DAV:}foo' => 'bar',
+          '{DAV:}foo2' => 'bla'
+        )
+
+        expected = {
+          '{DAV:}foo' => 200,
+          '{DAV:}foo2' => 201
+        }
+        assert_equal(expected, result)
+      end
+    end
+  end
+end

data/test/dav/simple_file_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class SimpleFileTest < Minitest::Test
+      def test_all
+        file = Tilia::Dav::SimpleFile.new('filename.txt', 'contents', 'text/plain')
+
+        assert_equal('filename.txt', file.name)
+        assert_equal('contents', file.get)
+        assert_equal(8, file.size)
+        assert_equal("\"#{Digest::SHA1.hexdigest('contents')}\"", file.etag)
+        assert_equal('text/plain', file.content_type)
+      end
+    end
+  end
+end

data/test/dav/string_util_test.rb

@@ -0,0 +1,92 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class StringUtilTest < Minitest::Test
+      def dataset
+        [
+          ['FOOBAR', 'FOO',    'i;octet', 'contains', true],
+          ['FOOBAR', 'foo',    'i;octet', 'contains', false],
+          ['FÖÖBAR', 'FÖÖ',    'i;octet', 'contains', true],
+          ['FÖÖBAR', 'föö',    'i;octet', 'contains', false],
+          ['FOOBAR', 'FOOBAR', 'i;octet', 'equals', true],
+          ['FOOBAR', 'fooBAR', 'i;octet', 'equals', false],
+          ['FOOBAR', 'FOO',    'i;octet', 'starts-with', true],
+          ['FOOBAR', 'foo',    'i;octet', 'starts-with', false],
+          ['FOOBAR', 'BAR',    'i;octet', 'starts-with', false],
+          ['FOOBAR', 'bar',    'i;octet', 'starts-with', false],
+          ['FOOBAR', 'FOO',    'i;octet', 'ends-with', false],
+          ['FOOBAR', 'foo',    'i;octet', 'ends-with', false],
+          ['FOOBAR', 'BAR',    'i;octet', 'ends-with', true],
+          ['FOOBAR', 'bar',    'i;octet', 'ends-with', false],
+
+          ['FOOBAR', 'FOO',    'i;ascii-casemap', 'contains', true],
+          ['FOOBAR', 'foo',    'i;ascii-casemap', 'contains', true],
+          ['FÖÖBAR', 'FÖÖ',    'i;ascii-casemap', 'contains', true],
+          ['FÖÖBAR', 'föö',    'i;ascii-casemap', 'contains', false],
+          ['FOOBAR', 'FOOBAR', 'i;ascii-casemap', 'equals', true],
+          ['FOOBAR', 'fooBAR', 'i;ascii-casemap', 'equals', true],
+          ['FOOBAR', 'FOO',    'i;ascii-casemap', 'starts-with', true],
+          ['FOOBAR', 'foo',    'i;ascii-casemap', 'starts-with', true],
+          ['FOOBAR', 'BAR',    'i;ascii-casemap', 'starts-with', false],
+          ['FOOBAR', 'bar',    'i;ascii-casemap', 'starts-with', false],
+          ['FOOBAR', 'FOO',    'i;ascii-casemap', 'ends-with', false],
+          ['FOOBAR', 'foo',    'i;ascii-casemap', 'ends-with', false],
+          ['FOOBAR', 'BAR',    'i;ascii-casemap', 'ends-with', true],
+          ['FOOBAR', 'bar',    'i;ascii-casemap', 'ends-with', true],
+
+          ['FOOBAR', 'FOO',    'i;unicode-casemap', 'contains', true],
+          ['FOOBAR', 'foo',    'i;unicode-casemap', 'contains', true],
+          ['FÖÖBAR', 'FÖÖ',    'i;unicode-casemap', 'contains', true],
+          ['FÖÖBAR', 'föö',    'i;unicode-casemap', 'contains', true],
+          ['FOOBAR', 'FOOBAR', 'i;unicode-casemap', 'equals', true],
+          ['FOOBAR', 'fooBAR', 'i;unicode-casemap', 'equals', true],
+          ['FOOBAR', 'FOO',    'i;unicode-casemap', 'starts-with', true],
+          ['FOOBAR', 'foo',    'i;unicode-casemap', 'starts-with', true],
+          ['FOOBAR', 'BAR',    'i;unicode-casemap', 'starts-with', false],
+          ['FOOBAR', 'bar',    'i;unicode-casemap', 'starts-with', false],
+          ['FOOBAR', 'FOO',    'i;unicode-casemap', 'ends-with', false],
+          ['FOOBAR', 'foo',    'i;unicode-casemap', 'ends-with', false],
+          ['FOOBAR', 'BAR',    'i;unicode-casemap', 'ends-with', true],
+          ['FOOBAR', 'bar',    'i;unicode-casemap', 'ends-with', true]
+        ]
+      end
+
+      def test_text_match
+        dataset.each do |data|
+          (haystack, needle, collation, match_type, result) = data
+          assert_equal(result, Tilia::Dav::StringUtil.text_match(haystack, needle, collation, match_type))
+        end
+      end
+
+      def test_bad_collation
+        assert_raises(Tilia::Dav::Exception::BadRequest) { Tilia::Dav::StringUtil.text_match('foobar', 'foo', 'blabla', 'contains') }
+      end
+
+      def test_bad_match_type
+        assert_raises(Tilia::Dav::Exception::BadRequest) { Tilia::Dav::StringUtil.text_match('foobar', 'foo', 'i;octet', 'booh') }
+      end
+
+      def test_ensure_utf8_ascii
+        input_string = 'harkema'
+        output_string = 'harkema'
+
+        assert_equal(output_string, Tilia::Dav::StringUtil.ensure_utf8(input_string))
+      end
+
+      def test_ensure_utf8_latin1
+        input_string = "m\u00fcnster"
+        output_string = 'münster'
+
+        assert_equal(output_string, Tilia::Dav::StringUtil.ensure_utf8(input_string))
+      end
+
+      def test_ensure_utf8_utf8
+        input_string = "m\xc3\xbcnster"
+        output_string = 'münster'
+
+        assert_equal(output_string, Tilia::Dav::StringUtil.ensure_utf8(input_string))
+      end
+    end
+  end
+end

data/test/dav/sync/mock_sync_collection.rb

@@ -0,0 +1,141 @@
+module Tilia
+  module Dav
+    module Sync
+      # This mocks a ISyncCollection, for unittesting.
+      #
+      # This object behaves the same as SimpleCollection. Call addChange to update
+      # the 'changelog' that this class uses for the collection.
+      class MockSyncCollection < SimpleCollection
+        include ISyncCollection
+
+        attr_accessor :change_log
+        attr_accessor :token
+
+        def initialize(*args)
+          super
+          @change_log = {}
+        end
+
+        # This method returns the current sync-token for this collection.
+        # This can be any string.
+        #
+        # If null is returned from this function, the plugin assumes there's no
+        # sync information available.
+        #
+        # @return string|null
+        def sync_token
+          # Will be 'null' in the first round, and will increment ever after.
+          @token
+        end
+
+        def add_change(added, modified, deleted)
+          @token ||= 0
+          @token += 1
+          @change_log[@token] = {
+            'added'     => added,
+            'modified'  => modified,
+            'deleted'   => deleted
+          }
+        end
+
+        # The getChanges method returns all the changes that have happened, since
+        # the specified syncToken and the current collection.
+        #
+        # This function should return an array, such as the following:
+        #
+        # array(
+        #   'syncToken' => 'The current synctoken',
+        #   'modified'   => array(
+        #      'new.txt',
+        #   ),
+        #   'deleted' => array(
+        #      'foo.php.bak',
+        #      'old.txt'
+        #   )
+        # )
+        #
+        # The syncToken property should reflect the *current* syncToken of the
+        # collection, as reported sync_token. This is needed here too, to
+        # ensure the operation is atomic.
+        #
+        # If the syncToken is specified as null, this is an initial sync, and all
+        # members should be reported.
+        #
+        # The modified property is an array of nodenames that have changed since
+        # the last token.
+        #
+        # The deleted property is an array with nodenames, that have been deleted
+        # from collection.
+        #
+        # The second argument is basically the 'depth' of the report. If it's 1,
+        # you only have to report changes that happened only directly in immediate
+        # descendants. If it's 2, it should also include changes from the nodes
+        # below the child collections. (grandchildren)
+        #
+        # The third (optional) argument allows a client to specify how many
+        # results should be returned at most. If the limit is not specified, it
+        # should be treated as infinite.
+        #
+        # If the limit (infinite or not) is higher than you're willing to return,
+        # you should throw a Sabre\DAV\Exception\Too_much_matches exception.
+        #
+        # If the syncToken is expired (due to data cleanup) or unknown, you must
+        # return null.
+        #
+        # The limit is 'suggestive'. You are free to ignore it.
+        #
+        # @param string sync_token
+        # @param int sync_level
+        # @param int limit
+        # @return array
+        def changes(sync_token, _sync_level, limit = nil)
+          # This is an initial sync
+          if sync_token.nil?
+            return {
+              'added' => children.map(&:name),
+              'modified' => [],
+              'deleted' => [],
+              'syncToken' => self.sync_token
+            }
+          end
+
+          return nil unless sync_token.to_i.to_s == sync_token.to_s
+          sync_token = sync_token.to_i
+
+          return nil if @token.nil?
+
+          added    = []
+          modified = []
+          deleted  = []
+
+          @change_log.each do |token, change|
+            next unless token > sync_token
+            added += change['added']
+            modified += change['modified']
+            deleted += change['deleted']
+
+            next unless limit
+            left = limit - (modified.size + deleted.size)
+
+            next if left > 0
+            break if left == 0
+            modified = modified[0..left - 1] if left < 0
+
+            left = limit - (modified.size + deleted.size)
+
+            break if left == 0
+            deleted = deleted[0..left - 1] if left < 0
+            break
+          end
+
+          {
+            'syncToken' => @token,
+            'added'     => added,
+            'modified'  => modified,
+            'deleted'   => deleted
+          }
+        end
+      end
+    end
+  end
+end

data/test/dav/sync/plugin_test.rb

@@ -0,0 +1,491 @@
+require 'yaml'
+
+module Tilia
+  module Dav
+    module Sync
+      class PluginTest < DavServerTest
+        def setup
+          super
+          @server.add_plugin(Plugin.new)
+        end
+
+        def test_get_info
+          assert_has_key('name', Plugin.new.plugin_info)
+        end
+
+        def set_up_tree
+          @collection = MockSyncCollection.new(
+            'coll',
+            [
+              SimpleFile.new('file1.txt', 'foo'),
+              SimpleFile.new('file2.txt', 'bar')
+            ]
+          )
+          @tree = [
+            @collection,
+            SimpleCollection.new('normalcoll', [])
+          ]
+        end
+
+        def test_supported_report_set
+          result = @server.properties('/coll', ['{DAV:}supported-report-set'])
+          refute(result['{DAV:}supported-report-set'].has('{DAV:}sync-collection'))
+
+          # Making a change
+          @collection.add_change(['file1.txt'], [], [])
+
+          result = @server.properties('/coll', ['{DAV:}supported-report-set'])
+          assert(result['{DAV:}supported-report-set'].has('{DAV:}sync-collection'))
+        end
+
+        def test_get_sync_token
+          result = @server.properties('/coll', ['{DAV:}sync-token'])
+          refute(result.key?('{DAV:}sync-token'))
+
+          # Making a change
+          @collection.add_change(['file1.txt'], [], [])
+
+          result = @server.properties('/coll', ['{DAV:}sync-token'])
+          assert_has_key('{DAV:}sync-token', result)
+
+          # non-sync-enabled collection
+          @collection.add_change(['file1.txt'], [], [])
+
+          result = @server.properties('/normalcoll', ['{DAV:}sync-token'])
+          refute(result.key?('{DAV:}sync-token'))
+        end
+
+        def test_sync_initial_sync_collection
+          # Making a change
+          @collection.add_change(['file1.txt'], [], [])
+
+          request = Http::Request.new('REPORT', '/coll/', 'Content-Type' => 'application/xml')
+
+          body = <<BLA
+<?xml version="1.0" encoding="utf-8" ?>
+<D:sync-collection xmlns:D="DAV:">
+<D:sync-token/>
+<D:sync-level>1</D:sync-level>
+<D:prop>
+  <D:getcontentlength/>
+</D:prop>
+</D:sync-collection>
+BLA
+
+          request.body = body
+
+          response = request(request)
+
+          assert_equal(207, response.status, "Full response body: #{response.body_as_string}")
+
+          multi_status = @server.xml.parse(response.body_as_string)
+
+          # Checking the sync-token
+          assert_equal(
+            'http://sabre.io/ns/sync/1',
+            multi_status.sync_token
+          )
+
+          responses = multi_status.responses
+          assert_equal(2, responses.size, 'We expected exactly 2 {DAV:}response')
+
+          response = responses[0]
+
+          assert_nil(response.http_status)
+          assert_equal('/coll/file1.txt', response.href)
+          assert_equal(
+            {
+              '200' => {
+                '{DAV:}getcontentlength' => '3'
+              }
+            },
+            response.response_properties
+          )
+
+          response = responses[1]
+
+          assert_nil(response.http_status)
+          assert_equal('/coll/file2.txt', response.href)
+          assert_equal(
+            {
+              '200' => {
+                '{DAV:}getcontentlength' => '3'
+              }
+            },
+            response.response_properties
+          )
+        end
+
+        def test_subsequent_sync_sync_collection
+          # Making a change
+          @collection.add_change(['file1.txt'], [], [])
+          # Making another change
+          @collection.add_change([], ['file2.txt'], ['file3.txt'])
+
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'REPORT',
+            'REQUEST_PATH'   => '/coll/',
+            'CONTENT_TYPE'    => 'application/xml'
+          )
+
+          body = <<BLA
+<?xml version="1.0" encoding="utf-8" ?>
+<D:sync-collection xmlns:D="DAV:">
+  <D:sync-token>http://sabre.io/ns/sync/1</D:sync-token>
+  <D:sync-level>infinite</D:sync-level>
+  <D:prop>
+    <D:getcontentlength/>
+  </D:prop>
+</D:sync-collection>
+BLA
+
+          request.body = body
+
+          response = request(request)
+
+          assert_equal(207, response.status, "Full response body: #{response.body}")
+
+          multi_status = @server.xml.parse(response.body_as_string)
+
+          # Checking the sync-token
+          assert_equal(
+            'http://sabre.io/ns/sync/2',
+            multi_status.sync_token
+          )
+
+          responses = multi_status.responses
+          assert_equal(2, responses.size, 'We expected exactly 2 {DAV:}response')
+
+          response = responses[0]
+
+          assert_nil(response.http_status)
+          assert_equal('/coll/file2.txt', response.href)
+          assert_equal(
+            {
+              '200' => {
+                '{DAV:}getcontentlength' => '3'
+              }
+            },
+            response.response_properties
+          )
+
+          response = responses[1]
+
+          assert_equal('404', response.http_status)
+          assert_equal('/coll/file3.txt', response.href)
+          assert_equal({}, response.response_properties)
+        end
+
+        def test_subsequent_sync_sync_collection_limit
+          # Making a change
+          @collection.add_change(['file1.txt'], [], [])
+          # Making another change
+          @collection.add_change([], ['file2.txt'], ['file3.txt'])
+
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'REPORT',
+            'REQUEST_PATH'   => '/coll/',
+            'CONTENT_TYPE'    => 'application/xml'
+          )
+
+          body = <<BLA
+<?xml version="1.0" encoding="utf-8" ?>
+<D:sync-collection xmlns:D="DAV:">
+  <D:sync-token>http://sabre.io/ns/sync/1</D:sync-token>
+  <D:sync-level>infinite</D:sync-level>
+  <D:prop>
+    <D:getcontentlength/>
+  </D:prop>
+  <D:limit><D:nresults>1</D:nresults></D:limit>
+</D:sync-collection>
+BLA
+
+          request.body = body
+
+          response = request(request)
+
+          assert_equal(207, response.status, "Full response body: #{response.body}")
+
+          multi_status = @server.xml.parse(response.body_as_string)
+
+          # Checking the sync-token
+          assert_equal(
+            'http://sabre.io/ns/sync/2',
+            multi_status.sync_token
+          )
+
+          responses = multi_status.responses
+          assert_equal(1, responses.size, 'We expected exactly 1 {DAV:}response')
+
+          response = responses[0]
+
+          assert_equal('404', response.http_status)
+          assert_equal('/coll/file3.txt', response.href)
+          assert_equal({}, response.response_properties)
+        end
+
+        def test_subsequent_sync_sync_collection_depth_fall_back
+          # Making a change
+          @collection.add_change(['file1.txt'], [], [])
+          # Making another change
+          @collection.add_change([], ['file2.txt'], ['file3.txt'])
+
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'REPORT',
+            'REQUEST_PATH'   => '/coll/',
+            'CONTENT_TYPE'   => 'application/xml',
+            'HTTP_DEPTH'     => '1'
+          )
+
+          body = <<BLA
+<?xml version="1.0" encoding="utf-8" ?>
+<D:sync-collection xmlns:D="DAV:">
+  <D:sync-token>http://sabre.io/ns/sync/1</D:sync-token>
+  <D:prop>
+    <D:getcontentlength/>
+  </D:prop>
+</D:sync-collection>
+BLA
+
+          request.body = body
+
+          response = request(request)
+
+          assert_equal(207, response.status, "Full response body: #{response.body}")
+
+          multi_status = @server.xml.parse(response.body_as_string)
+
+          # Checking the sync-token
+          assert_equal(
+            'http://sabre.io/ns/sync/2',
+            multi_status.sync_token
+          )
+
+          responses = multi_status.responses
+          assert_equal(2, responses.size, 'We expected exactly 2 {DAV:}response')
+
+          response = responses[0]
+
+          assert_nil(response.http_status)
+          assert_equal('/coll/file2.txt', response.href)
+          assert_equal(
+            {
+              '200' => {
+                '{DAV:}getcontentlength' => '3'
+              }
+            },
+            response.response_properties
+          )
+          response = responses[1]
+
+          assert_equal('404', response.http_status)
+          assert_equal('/coll/file3.txt', response.href)
+          assert_equal({}, response.response_properties)
+        end
+
+        def test_sync_no_sync_info
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'REPORT',
+            'REQUEST_PATH'   => '/coll/',
+            'CONTENT_TYPE'    => 'application/xml'
+          )
+
+          body = <<BLA
+<?xml version="1.0" encoding="utf-8" ?>
+<D:sync-collection xmlns:D="DAV:">
+  <D:sync-token/>
+  <D:sync-level>1</D:sync-level>
+  <D:prop>
+    <D:getcontentlength/>
+  </D:prop>
+</D:sync-collection>
+BLA
+
+          request.body = body
+
+          response = request(request)
+
+          # The default state has no sync-token, so this report should not yet
+          # be supported.
+          assert_equal(415, response.status, "Full response body: #{response.body}")
+        end
+
+        def test_sync_no_sync_collection
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'REPORT',
+            'REQUEST_PATH'   => '/normalcoll/',
+            'CONTENT_TYPE'    => 'application/xml'
+          )
+
+          body = <<BLA
+<?xml version="1.0" encoding="utf-8" ?>
+<D:sync-collection xmlns:D="DAV:">
+  <D:sync-token/>
+  <D:sync-level>1</D:sync-level>
+  <D:prop>
+    <D:getcontentlength/>
+  </D:prop>
+</D:sync-collection>
+BLA
+
+          request.body = body
+
+          response = request(request)
+
+          # The default state has no sync-token, so this report should not yet
+          # be supported.
+          assert_equal(415, response.status, "Full response body: #{response.body}")
+        end
+
+        def test_sync_invalid_token
+          @collection.add_change(['file1.txt'], [], [])
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'REPORT',
+            'REQUEST_PATH'   => '/coll/',
+            'CONTENT_TYPE'    => 'application/xml'
+          )
+
+          body = <<BLA
+<?xml version="1.0" encoding="utf-8" ?>
+<D:sync-collection xmlns:D="DAV:">
+  <D:sync-token>http://sabre.io/ns/sync/invalid</D:sync-token>
+  <D:sync-level>1</D:sync-level>
+  <D:prop>
+    <D:getcontentlength/>
+  </D:prop>
+</D:sync-collection>
+BLA
+
+          request.body = body
+
+          response = request(request)
+
+          # The default state has no sync-token, so this report should not yet
+          # be supported.
+          assert_equal(403, response.status, "Full response body: #{response.body}")
+        end
+
+        def test_sync_invalid_token_no_prefix
+          @collection.add_change(['file1.txt'], [], [])
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'REPORT',
+            'REQUEST_PATH'   => '/coll/',
+            'CONTENT_TYPE'    => 'application/xml'
+          )
+
+          body = <<BLA
+<?xml version="1.0" encoding="utf-8" ?>
+<D:sync-collection xmlns:D="DAV:">
+  <D:sync-token>invalid</D:sync-token>
+  <D:sync-level>1</D:sync-level>
+  <D:prop>
+    <D:getcontentlength/>
+  </D:prop>
+</D:sync-collection>
+BLA
+
+          request.body = body
+
+          response = request(request)
+
+          # The default state has no sync-token, so this report should not yet
+          # be supported.
+          assert_equal(403, response.status, "Full response body: #{response.body}")
+        end
+
+        def test_sync_no_sync_token
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'REPORT',
+            'REQUEST_PATH'   => '/coll/',
+            'CONTENT_TYPE'    => 'application/xml'
+          )
+
+          body = <<BLA
+<?xml version="1.0" encoding="utf-8" ?>
+<D:sync-collection xmlns:D="DAV:">
+  <D:sync-level>1</D:sync-level>
+  <D:prop>
+    <D:getcontentlength/>
+  </D:prop>
+</D:sync-collection>
+BLA
+
+          request.body = body
+
+          response = request(request)
+
+          # The default state has no sync-token, so this report should not yet
+          # be supported.
+          assert_equal(400, response.status, "Full response body: #{response.body}")
+        end
+
+        def test_sync_no_prop
+          @collection.add_change(['file1.txt'], [], [])
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'REPORT',
+            'REQUEST_PATH'   => '/coll/',
+            'CONTENT_TYPE'   => 'application/xml'
+          )
+
+          body = <<BLA
+<?xml version="1.0" encoding="utf-8" ?>
+<D:sync-collection xmlns:D="DAV:">
+  <D:sync-token />
+  <D:sync-level>1</D:sync-level>
+</D:sync-collection>
+BLA
+
+          request.body = body
+
+          response = request(request)
+
+          # The default state has no sync-token, so this report should not yet
+          # be supported.
+          assert_equal(400, response.status, "Full response body: #{response.body}")
+        end
+
+        def test_if_conditions
+          @collection.add_change(['file1.txt'], [], [])
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'DELETE',
+            'REQUEST_PATH'   => '/coll/file1.txt',
+            'HTTP_IF'        => '</coll> (<http://sabre.io/ns/sync/1>)'
+          )
+          response = request(request)
+
+          # If a 403 is thrown this works correctly. The file in questions
+          # doesn't allow itself to be deleted.
+          # If the If conditions failed, it would have been a 412 instead.
+          assert_equal(403, response.status)
+        end
+
+        def test_if_conditions_not
+          @collection.add_change(['file1.txt'], [], [])
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'DELETE',
+            'REQUEST_PATH'   => '/coll/file1.txt',
+            'HTTP_IF'        => '</coll> (Not <http://sabre.io/ns/sync/2>)'
+          )
+          response = request(request)
+
+          # If a 403 is thrown this works correctly. The file in questions
+          # doesn't allow itself to be deleted.
+          # If the If conditions failed, it would have been a 412 instead.
+          assert_equal(403, response.status)
+        end
+
+        def test_if_conditions_no_sync_token
+          @collection.add_change(['file1.txt'], [], [])
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD' => 'DELETE',
+            'REQUEST_PATH'   => '/coll/file1.txt',
+            'HTTP_IF'        => '</coll> (<opaquelocktoken:foo>)'
+          )
+          response = request(request)
+
+          assert_equal(412, response.status)
+        end
+      end
+    end
+  end
+end