tilia-dav 3.1.0.pre.alpha2

data/test/dav/locks/backend/file_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Locks
+      module Backend
+        class FileTest < Minitest::Test
+          include AbstractTest
+
+          def backend
+            @temp_dir = Dir.mktmpdir
+
+            backend = File.new("#{@temp_dir}/lockdb")
+            backend
+          end
+
+          def teardown
+            FileUtils.remove_entry @temp_dir
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/locks/backend/mock.rb

@@ -0,0 +1,82 @@
+module Tilia
+  module Dav
+    module Locks
+      module Backend
+        # Locks Mock backend.
+        #
+        # This backend stores lock information in memory. Mainly useful for testing.
+        class Mock < AbstractBackend
+          # Returns a list of Sabre\DAV\Locks\LockInfo objects
+          #
+          # This method should return all the locks for a particular uri, including
+          # locks that might be set on a parent uri.
+          #
+          # If returnChildLocks is set to true, this method should also look for
+          # any locks in the subtree of the uri for locks.
+          #
+          # @param string uri
+          # @param bool return_child_locks
+          # @return array
+          def locks(uri, return_child_locks)
+            new_locks = []
+
+            @locks.each do |lock|
+              next unless lock.uri == uri ||
+                          # deep locks on parents
+                          (lock.depth != 0 && uri.index("#{lock.uri}/") == 0) ||
+
+                          # locks on children
+                          (return_child_locks && (lock.uri.index("#{uri}/") == 0))
+              new_locks << lock
+            end
+
+            # Checking if we can remove any of these locks
+            new_locks.delete_if do |lock|
+              Time.now.to_i > lock.timeout + lock.created
+            end
+            new_locks
+          end
+
+          # Locks a uri
+          #
+          # @param string uri
+          # @param LockInfo lock_info
+          # @return bool
+          def lock(uri, lock_info)
+            # We're making the lock timeout 30 minutes
+            lock_info.timeout = 1800
+            lock_info.created = Time.now.to_i
+            lock_info.uri = uri
+
+            @locks.delete_if do |lock|
+              (lock.token == lock_info.token) || (Time.now.to_i > lock.timeout + lock.created)
+            end
+
+            @locks << lock_info
+            true
+          end
+
+          # Removes a lock from a uri
+          #
+          # @param string uri
+          # @param LockInfo lock_info
+          # @return bool
+          def unlock(_uri, lock_info)
+            @locks.each_with_index do |lock, k|
+              if lock.token == lock_info.token
+                @locks.delete_at(k)
+                return true
+              end
+            end
+
+            false
+          end
+
+          def initialize
+            @locks = []
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/locks/backend/sequel_my_sql_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Locks
+      module Backend
+        class SequelMySqlTest < Minitest::Test
+          include AbstractTest
+
+          def backend
+            db = TestUtil.mysql
+            db.run('DROP TABLE IF EXISTS locks')
+            db.run(<<QUERY
+CREATE TABLE locks (
+  id INTEGER UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,
+  owner VARCHAR(100),
+  timeout INTEGER UNSIGNED,
+  created INTEGER,
+  token VARCHAR(100),
+  scope TINYINT,
+  depth TINYINT,
+  uri VARCHAR(255)
+) #{TestUtil.mysql_engine}
+QUERY
+                  )
+            Sequel.new(db)
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/locks/backend/sequel_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Locks
+      module Backend
+        class SequelTest < Minitest::Test
+          include AbstractTest
+
+          def backend
+            db = TestUtil.sqlite
+            db.run('CREATE TABLE locks ( id integer primary key asc, owner text, timeout text, created integer, token text, scope integer, depth integer, uri text)')
+            Sequel.new(db)
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/locks/ms_word_test.rb

@@ -0,0 +1,119 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Locks
+      class MSWordTest < Minitest::Test
+        def setup
+          @temp_dir = Dir.mktmpdir
+        end
+
+        def teardown
+          FileUtils.remove_entry @temp_dir
+        end
+
+        def test_lock_etc
+          Dir.mkdir("#{@temp_dir}/mstest")
+          tree = Fs::Directory.new("#{@temp_dir}/mstest")
+
+          server = ServerMock.new(tree)
+          server.debug_exceptions = true
+          locks_backend = Backend::File.new("#{@temp_dir}/locksdb")
+          locks_plugin = Plugin.new(locks_backend)
+          server.add_plugin(locks_plugin)
+
+          response1 = Http::ResponseMock.new
+
+          server.http_request = lock_request
+          server.http_response = response1
+          server.sapi = Http::SapiMock.new
+          server.exec
+
+          assert_equal(201, server.http_response.status, "Full response body: #{response1.body_as_string}")
+          assert(server.http_response.header('Lock-Token'))
+          lock_token = server.http_response.header('Lock-Token')
+
+          # sleep(10)
+
+          response2 = Http::ResponseMock.new
+
+          server.http_request = lock_request2
+          server.http_response = response2
+          server.exec
+
+          assert_equal(201, server.http_response.status)
+          assert(server.http_response.header('Lock-Token'))
+
+          # sleep(10)
+
+          response3 = Http::ResponseMock.new
+          server.http_request = get_put_request(lock_token)
+          server.http_response = response3
+          server.exec
+
+          assert_equal(204, server.http_response.status)
+        end
+
+        def lock_request
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD'    => 'LOCK',
+            'HTTP_CONTENT_TYPE' => 'application/xml',
+            'HTTP_TIMEOUT'      => 'Second-3600',
+            'REQUEST_PATH'      => '/Nouveau%20Microsoft%20Office%20Excel%20Worksheet.xlsx'
+          )
+
+          request.body = <<XML
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope>
+    <D:exclusive />
+  </D:lockscope>
+  <D:locktype>
+    <D:write />
+  </D:locktype>
+  <D:owner>
+    <D:href>PC-Vista\User</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          request
+        end
+
+        def lock_request2
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD'    => 'LOCK',
+            'HTTP_CONTENT_TYPE' => 'application/xml',
+            'HTTP_TIMEOUT'      => 'Second-3600',
+            'REQUEST_PATH'      => '/~$Nouveau%20Microsoft%20Office%20Excel%20Worksheet.xlsx'
+          )
+
+          request.body = <<XML
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope>
+    <D:exclusive />
+  </D:lockscope>
+  <D:locktype>
+    <D:write />
+  </D:locktype>
+  <D:owner>
+    <D:href>PC-Vista\User</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          request
+        end
+
+        def get_put_request(lock_token)
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_METHOD'    => 'PUT',
+            'REQUEST_PATH'      => '/Nouveau%20Microsoft%20Office%20Excel%20Worksheet.xlsx',
+            'HTTP_IF'           => "If: (#{lock_token})"
+          )
+          request.body = 'FAKE BODY'
+          request
+        end
+      end
+    end
+  end
+end

data/test/dav/locks/plugin2_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Locks
+      class Plugin2Test < DavServerTest
+        def setup
+          @setup_locks = true
+          super
+        end
+
+        def set_up_tree
+          @tree = Fs::Directory.new(@temp_dir)
+        end
+
+        # This test first creates a file with LOCK and then deletes it.
+        #
+        # After deleting the file, the lock should no longer be in the lock
+        # backend.
+        #
+        # Reported in ticket #487
+        def test_unlock_after_delete
+          body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+    <D:lockscope><D:exclusive/></D:lockscope>
+    <D:locktype><D:write/></D:locktype>
+</D:lockinfo>
+XML
+
+          request = Http::Request.new(
+            'LOCK',
+            '/file.txt',
+            {},
+            body
+          )
+          response = request(request)
+          assert_equal(201, response.status, response.body_as_string)
+
+          assert_equal(
+            1,
+            @locks_backend.locks('file.txt', true).size
+          )
+
+          request = Http::Request.new(
+            'DELETE',
+            '/file.txt',
+            'If' => "(#{response.header('Lock-Token')})"
+          )
+          response = request(request)
+          assert_equal(204, response.status, response.body_as_string)
+
+          assert_equal(
+            0,
+            @locks_backend.locks('file.txt', true).size
+          )
+        end
+      end
+    end
+  end
+end

data/test/dav/locks/plugin_test.rb

@@ -0,0 +1,896 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Locks
+      class PluginTest < AbstractServer
+        def setup
+          super
+
+          locks_backend = Backend::File.new("#{@temp_dir}/locksdb")
+          @locks_plugin = Plugin.new(locks_backend)
+          @server.add_plugin(@locks_plugin)
+        end
+
+        def test_get_info
+          assert_has_key('name', @locks_plugin.plugin_info)
+        end
+
+        def test_get_features
+          assert_equal([2], @locks_plugin.features)
+        end
+
+        def test_get_http_methods
+          assert_equal(['LOCK', 'UNLOCK'], @locks_plugin.http_methods(''))
+        end
+
+        def test_lock_no_body
+          request = Http::Request.new('LOCK', '/test.txt')
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(
+            {
+              'X-Sabre-Version' => [Version::VERSION],
+              'Content-Type' => ['application/xml; charset=utf-8']
+            },
+            @response.headers
+          )
+
+          assert_equal(400, @response.status)
+        end
+
+        def test_lock
+          request = Http::Request.new('LOCK', '/test.txt')
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(200, @response.status, "Got an incorrect status back. Response body: #{@response.body_as_string}")
+
+          body = @response.body.gsub(/xmlns(:[A-Za-z0-9_])?=("|')DAV:("|')/) { "xmlns#{Regexp.last_match(1)}=\"urn:DAV\"" }
+
+          xml = LibXML::XML::Document.string(body)
+
+          elements = [
+            '/d:prop',
+            '/d:prop/d:lockdiscovery',
+            '/d:prop/d:lockdiscovery/d:activelock',
+            '/d:prop/d:lockdiscovery/d:activelock/d:locktype',
+            '/d:prop/d:lockdiscovery/d:activelock/d:lockroot',
+            '/d:prop/d:lockdiscovery/d:activelock/d:lockroot/d:href',
+            '/d:prop/d:lockdiscovery/d:activelock/d:locktype/d:write',
+            '/d:prop/d:lockdiscovery/d:activelock/d:lockscope',
+            '/d:prop/d:lockdiscovery/d:activelock/d:lockscope/d:exclusive',
+            '/d:prop/d:lockdiscovery/d:activelock/d:depth',
+            '/d:prop/d:lockdiscovery/d:activelock/d:owner',
+            '/d:prop/d:lockdiscovery/d:activelock/d:timeout',
+            '/d:prop/d:lockdiscovery/d:activelock/d:locktoken',
+            '/d:prop/d:lockdiscovery/d:activelock/d:locktoken/d:href'
+          ]
+
+          elements.each do |elem|
+            data = xml.find(elem)
+            assert_equal(1, data.size, "We expected 1 match for the xpath expression \"#{elem}\". #{data.size} were found. Full response body: #{@response.body_as_string}")
+          end
+
+          depth = xml.find('/d:prop/d:lockdiscovery/d:activelock/d:depth')
+          assert_equal('infinity', depth[0].content)
+
+          token = xml.find('/d:prop/d:lockdiscovery/d:activelock/d:locktoken/d:href')
+          assert_equal(@response.header('Lock-Token'), "<#{token[0].content}>", 'Token in response body didn\'t match token in response header.')
+        end
+
+        def test_double_lock
+          request = Http::Request.new('LOCK', '/test.txt')
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          @response = Http::ResponseMock.new
+          @server.http_response = @response
+
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+
+          assert_equal(423, @response.status, "Full response: #{@response.body_as_string}")
+        end
+
+        def test_lock_refresh
+          request = Http::Request.new('LOCK', '/test.txt')
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          lock_token = @response.header('Lock-Token')
+
+          @response = Http::ResponseMock.new
+          @server.http_response = @response
+
+          request = Http::Request.new('LOCK', '/test.txt', 'If' => "(#{lock_token})")
+          request.body = ''
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+
+          assert_equal(200, @response.status, "We received an incorrect status code. Full response body: #{@response.body_as_string}")
+        end
+
+        def test_lock_refresh_bad_token
+          request = Http::Request.new('LOCK', '/test.txt')
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          lock_token = @response.header('Lock-Token')
+
+          @response = Http::ResponseMock.new
+          @server.http_response = @response
+
+          request = Http::Request.new('LOCK', '/test.txt', 'If' => "(#{lock_token}foobar) (<opaquelocktoken:anotherbadtoken>)")
+          request.body = ''
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+
+          assert_equal(423, @response.status, "We received an incorrect status code. Full response body: #{@response.body_as_string}")
+        end
+
+        def test_lock_no_file
+          request = Http::Request.new('LOCK', '/notfound.txt')
+          request.body = <<XML
+<?xml version="1.0"?>
+  <D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(201, @response.status)
+        end
+
+        def test_unlock_no_token
+          request = Http::Request.new('UNLOCK', '/test.txt')
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(
+            {
+              'X-Sabre-Version' => [Version::VERSION],
+              'Content-Type' => ['application/xml; charset=utf-8']
+            },
+            @response.headers
+          )
+
+          assert_equal(400, @response.status)
+        end
+
+        def test_unlock_bad_token
+          request = Http::Request.new('UNLOCK', '/test.txt', 'Lock-Token' => '<opaquelocktoken:blablabla>')
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(
+            {
+              'X-Sabre-Version' => [Version::VERSION],
+              'Content-Type' => ['application/xml; charset=utf-8']
+            },
+            @response.headers
+          )
+
+          assert_equal(409, @response.status, "Got an incorrect status code. Full response body: #{@response.body_as_string}")
+        end
+
+        def test_lock_put_no_token
+          request = Http::Request.new('LOCK', '/test.txt')
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(200, @response.status)
+
+          request = Http::Request.new('PUT', '/test.txt')
+          request.body = 'newbody'
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(423, @response.status)
+        end
+
+        def test_unlock
+          request = Http::Request.new('LOCK', '/test.txt')
+          @server.http_request = request
+
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.invoke_method(request, @server.http_response)
+          lock_token = @server.http_response.header('Lock-Token')
+
+          request = Http::Request.new('UNLOCK', '/test.txt', 'Lock-Token' => lock_token)
+          @server.http_request = request
+          @server.http_response = Http::ResponseMock.new
+          @server.invoke_method(request, @server.http_response)
+
+          assert_equal(204, @server.http_response.status, "Got an incorrect status code. Full response body: #{@response.body_as_string}")
+          assert_equal(
+            {
+              'X-Sabre-Version' => [Version::VERSION],
+              'Content-Length' => ['0']
+            },
+            @server.http_response.headers
+          )
+        end
+
+        def test_unlock_windows_bug
+          request = Http::Request.new('LOCK', '/test.txt')
+          @server.http_request = request
+
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.invoke_method(request, @server.http_response)
+          lock_token = @server.http_response.header('Lock-Token')
+
+          # See Issue 123
+          lock_token = lock_token.gsub(/^(<>)+|(<>)+$/, '')
+
+          request = Http::Request.new('UNLOCK', '/test.txt', 'Lock-Token' => lock_token)
+          @server.http_request = request
+          @server.http_response = Http::ResponseMock.new
+          @server.invoke_method(request, @server.http_response)
+
+          assert_equal(204, @server.http_response.status, "Got an incorrect status code. Full response body: #{@response.body_as_string}")
+          assert_equal(
+            {
+              'X-Sabre-Version' => [Version::VERSION],
+              'Content-Length' => ['0']
+            },
+            @server.http_response.headers
+          )
+        end
+
+        def test_lock_retain_owner
+          request = Http::Sapi.create_from_server_array(
+            'REQUEST_PATH'   => '/test.txt',
+            'REQUEST_METHOD' => 'LOCK'
+          )
+          @server.http_request = request
+
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>Evert</D:owner>
+</D:lockinfo>
+XML
+
+          @server.invoke_method(request, @server.http_response)
+          lock_token = @server.http_response.header('Lock-Token')
+
+          locks = @locks_plugin.locks('test.txt')
+          assert_equal(1, locks.size)
+          assert_equal('Evert', locks[0].owner)
+        end
+
+        def test_lock_put_bad_token
+          server_vars = {
+            'REQUEST_PATH'   => '/test.txt',
+            'REQUEST_METHOD' => 'LOCK'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(200, @response.status)
+
+          server_vars = {
+            'REQUEST_PATH'   => '/test.txt',
+            'REQUEST_METHOD' => 'PUT',
+            'HTTP_IF' => '(<opaquelocktoken:token1>)'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = 'newbody'
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          # assert_equal('412 Precondition failed',@response.status)
+          assert_equal(423, @response.status)
+        end
+
+        def test_lock_delete_parent
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'LOCK'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(200, @response.status)
+
+          server_vars = {
+            'REQUEST_PATH'   => '/dir',
+            'REQUEST_METHOD' => 'DELETE'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(423, @response.status)
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+        end
+
+        def test_lock_delete_succeed
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'LOCK'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(200, @response.status)
+
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'DELETE',
+            'HTTP_IF' => "(#{@response.header('Lock-Token')})"
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(204, @response.status)
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+        end
+
+        def test_lock_copy_lock_source
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'LOCK'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(200, @response.status)
+
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'COPY',
+            'HTTP_DESTINATION' => '/dir/child2.txt'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(201, @response.status, 'Copy must succeed if only the source is locked, but not the destination')
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+        end
+
+        def test_lock_copy_lock_destination
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child2.txt',
+            'REQUEST_METHOD' => 'LOCK'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(201, @response.status)
+
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'COPY',
+            'HTTP_DESTINATION' => '/dir/child2.txt'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(423, @response.status, 'Copy must succeed if only the source is locked, but not the destination')
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+        end
+
+        def test_lock_move_lock_source_locked
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'LOCK'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(200, @response.status)
+
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'MOVE',
+            'HTTP_DESTINATION' => '/dir/child2.txt'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(423, @response.status, 'Copy must succeed if only the source is locked, but not the destination')
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+        end
+
+        def test_lock_move_lock_source_succeed
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'LOCK'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(200, @response.status)
+
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'MOVE',
+            'HTTP_DESTINATION' => '/dir/child2.txt',
+            'HTTP_IF' => "(#{@response.header('Lock-Token')})"
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(201, @response.status, "A valid lock-token was provided for the source, so this MOVE operation must succeed. Full response body: #{@response.body_as_string}")
+        end
+
+        def test_lock_move_lock_destination
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child2.txt',
+            'REQUEST_METHOD' => 'LOCK'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(201, @response.status)
+
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'MOVE',
+            'HTTP_DESTINATION' => '/dir/child2.txt'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(423, @response.status, 'Copy must succeed if only the source is locked, but not the destination')
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+        end
+
+        def test_lock_move_lock_parent
+          server_vars = {
+            'REQUEST_PATH'   => '/dir',
+            'REQUEST_METHOD' => 'LOCK',
+            'HTTP_DEPTH' => 'infinite'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(200, @response.status)
+
+          server_vars = {
+            'REQUEST_PATH'   => '/dir/child.txt',
+            'REQUEST_METHOD' => 'MOVE',
+            'HTTP_DESTINATION' => '/dir/child2.txt',
+            'HTTP_IF' => "</dir> (#{@response.header('Lock-Token')})"
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          @server.http_request = request
+          @server.exec
+
+          assert_equal(201, @response.status, 'We locked the parent of both the source and destination, but the move didn\'t succeed.')
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+        end
+
+        def test_lock_put_good_token
+          server_vars = {
+            'REQUEST_PATH'   => '/test.txt',
+            'REQUEST_METHOD' => 'LOCK'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(200, @response.status)
+
+          server_vars = {
+            'REQUEST_PATH'   => '/test.txt',
+            'REQUEST_METHOD' => 'PUT',
+            'HTTP_IF' => "(#{@response.header('Lock-Token')})"
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = 'newbody'
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(204, @response.status)
+        end
+
+        def test_lock_put_unrelated_token
+          request = Http::Request.new('LOCK', '/unrelated.txt')
+          request.body = <<XML
+<?xml version="1.0"?>
+<D:lockinfo xmlns:D="DAV:">
+  <D:lockscope><D:exclusive/></D:lockscope>
+  <D:locktype><D:write/></D:locktype>
+  <D:owner>
+    <D:href>http://example.org/~ejw/contact.html</D:href>
+  </D:owner>
+</D:lockinfo>
+XML
+
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(201, @response.status)
+
+          request = Http::Request.new(
+            'PUT',
+            '/test.txt',
+            'If' => "</unrelated.txt> (#{@response.header('Lock-Token')})"
+          )
+          request.body = 'newbody'
+          @server.http_request = request
+          @server.exec
+
+          assert_equal('application/xml; charset=utf-8', @response.header('Content-Type'))
+          assert(@response.header('Lock-Token') =~ /^<opaquelocktoken:(.*)>$/, "We did not get a valid Locktoken back (#{@response.header('Lock-Token')})")
+
+          assert_equal(204, @response.status)
+        end
+
+        def test_put_with_incorrect_etag
+          server_vars = {
+            'REQUEST_PATH'   => '/test.txt',
+            'REQUEST_METHOD' => 'PUT',
+            'HTTP_IF' => '(["etag1"])'
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = 'newbody'
+          @server.http_request = request
+          @server.exec
+          assert_equal(412, @response.status)
+        end
+
+        def test_put_with_correct_etag
+          # We need an ETag-enabled file node.
+          tree = Tree.new(FsExt::Directory.new(@temp_dir))
+          @server.tree = tree
+
+          filename = "#{@temp_dir}/test.txt"
+          stat = ::File.stat(filename)
+          etag = Digest::SHA1.hexdigest(stat.ino.to_s + stat.size.to_s + stat.mtime.to_s)
+          server_vars = {
+            'REQUEST_PATH'   => '/test.txt',
+            'REQUEST_METHOD' => 'PUT',
+            'HTTP_IF' => "([\"#{etag}\"])"
+          }
+
+          request = Http::Sapi.create_from_server_array(server_vars)
+          request.body = 'newbody'
+          @server.http_request = request
+          @server.exec
+          assert_equal(204, @response.status, "Incorrect status received. Full response body:#{@response.body_as_string}")
+        end
+
+        def test_delete_with_etag_on_collection
+          server_vars = {
+            'REQUEST_PATH'   => '/dir',
+            'REQUEST_METHOD' => 'DELETE',
+            'HTTP_IF' => '(["etag1"])'
+          }
+          request = Http::Sapi.create_from_server_array(server_vars)
+
+          @server.http_request = request
+          @server.exec
+          assert_equal(412, @response.status)
+        end
+
+        def test_get_timeout_header
+          request = Http::Sapi.create_from_server_array(
+            'HTTP_TIMEOUT' => 'second-100'
+          )
+
+          @server.http_request = request
+          assert_equal(100, @locks_plugin.timeout_header)
+        end
+
+        def test_get_timeout_header_two_items
+          request = Http::Sapi.create_from_server_array(
+            'HTTP_TIMEOUT' => 'second-5, infinite'
+          )
+
+          @server.http_request = request
+          assert_equal(5, @locks_plugin.timeout_header)
+        end
+
+        def test_get_timeout_header_infinite
+          request = Http::Sapi.create_from_server_array(
+            'HTTP_TIMEOUT' => 'infinite, second-5'
+          )
+
+          @server.http_request = request
+          assert_equal(LockInfo::TIMEOUT_INFINITE, @locks_plugin.timeout_header)
+        end
+
+        def test_get_timeout_header_invalid
+          request = Http::Sapi.create_from_server_array(
+            'HTTP_TIMEOUT' => 'yourmom'
+          )
+
+          @server.http_request = request
+          assert_raises(Exception::BadRequest) { @locks_plugin.timeout_header }
+        end
+      end
+    end
+  end
+end