tilia-dav 3.1.0.pre.alpha2

data/test/dav/sync_token_property_test.rb

@@ -0,0 +1,105 @@
+module Tilia
+  module Dav
+    class SyncTokenPropertyTest < DavServerTest
+      # The assumption in these tests is that a PROPFIND is going on, and to
+      # fetch the sync-token, the event handler is just able to use the existing
+      # result.
+      def test_already_there1
+        data.each do |v|
+          (name, value) = v
+
+          prop_find = PropFind.new(
+            'foo',
+            [
+              '{http://calendarserver.org/ns/}getctag',
+              name
+            ]
+          )
+
+          prop_find.set(name, value)
+          core_plugin = CorePlugin.new
+          core_plugin.prop_find_late(prop_find, SimpleCollection.new('hi'))
+
+          assert_equal('hello', prop_find.get('{http://calendarserver.org/ns/}getctag'))
+        end
+      end
+
+      # In these test-cases, the plugin is forced to do a local propfind to
+      # fetch the items.
+      def test_refetch
+        data.each do |v|
+          (name, value) = v
+
+          @server.tree = Tree.new(
+            SimpleCollection.new(
+              'root',
+              [
+                Mock::PropertiesCollection.new(
+                  'foo',
+                  [],
+                  name => value
+                )
+              ]
+            )
+          )
+          prop_find = PropFind.new(
+            'foo',
+            [
+              '{http://calendarserver.org/ns/}getctag',
+              name
+            ]
+          )
+
+          core_plugin = @server.plugin('core')
+          core_plugin.prop_find_late(prop_find, SimpleCollection.new('hi'))
+
+          assert_equal('hello', prop_find.get('{http://calendarserver.org/ns/}getctag'))
+        end
+      end
+
+      def test_no_data
+        @server.tree = Tree.new(
+          SimpleCollection.new(
+            'root',
+            [
+              Mock::PropertiesCollection.new(
+                'foo',
+                [],
+                {}
+              )
+            ]
+          )
+        )
+
+        prop_find = PropFind.new(
+          'foo',
+          [
+            '{http://calendarserver.org/ns/}getctag'
+          ]
+        )
+
+        core_plugin = @server.plugin('core')
+        core_plugin.prop_find_late(prop_find, SimpleCollection.new('hi'))
+
+        assert_nil(prop_find.get('{http://calendarserver.org/ns/}getctag'))
+      end
+
+      def data
+        [
+          [
+            '{http://sabredav.org/ns}sync-token',
+            'hello'
+          ],
+          [
+            '{DAV:}sync-token',
+            'hello'
+          ],
+          [
+            '{DAV:}sync-token',
+            Xml::Property::Href.new(Sync::Plugin::SYNCTOKEN_PREFIX + 'hello', false)
+          ]
+        ]
+      end
+    end
+  end
+end

data/test/dav/temporary_file_filter_test.rb

@@ -0,0 +1,179 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class TemporaryFileFilterTest < AbstractServer
+      def setup
+        super
+        plugin = Tilia::Dav::TemporaryFileFilterPlugin.new(::File.join(@temp_dir, '/tff'))
+        @server.add_plugin(plugin)
+      end
+
+      def test_put_normal
+        request = Tilia::Http::Request.new('PUT', '/testput.txt', {}, 'Testing new file')
+
+        @server.http_request = request
+        @server.exec
+
+        assert_equal(nil, @response.body)
+        assert_equal(201, @response.status)
+        assert_equal('0', @response.header('Content-Length'))
+
+        assert_equal('Testing new file', ::File.readlines(::File.join(@temp_dir, 'testput.txt')).join(''))
+      end
+
+      def test_put_temp
+        # mimicking an OS/X resource fork
+        request = Tilia::Http::Request.new('PUT', '/._testput.txt', [], 'Testing new file')
+
+        @server.http_request = request
+        @server.exec
+
+        assert_equal(nil, @response.body)
+        assert_equal(201, @response.status)
+        assert_equal({ 'X-Sabre-Temp' => ['true'] }, @response.headers)
+
+        refute(::File.exist?(::File.join(@temp_dir, '._testput.txt'))) # ._testput.txt should not exist in the regular file structure.
+      end
+
+      def test_put_temp_if_none_match
+        # mimicking an OS/X resource fork
+        request = Tilia::Http::Request.new('PUT', '/._testput.txt', { 'If-None-Match' => '*' }, 'Testing new file')
+
+        @server.http_request = request
+        @server.exec
+
+        assert_equal(nil, @response.body)
+        assert_equal(201, @response.status)
+        assert_equal({ 'X-Sabre-Temp' => ['true'] }, @response.headers)
+
+        refute(::File.exist?(::File.join(@temp_dir, '._testput.txt'))) # _testput.txt should not exist in the regular file structure.
+
+        @server.exec
+
+        assert_equal(412, @response.status)
+        assert_equal(
+          {
+            'X-Sabre-Temp' => ['true'],
+            'Content-Type' => ['application/xml; charset=utf-8']
+          },
+          @response.headers
+        )
+      end
+
+      def test_put_get
+        # mimicking an OS/X resource fork
+        request = Tilia::Http::Request.new('PUT', '/._testput.txt', [], 'Testing new file')
+        @server.http_request = request
+        @server.exec
+
+        assert_equal(nil, @response.body)
+        assert_equal(201, @response.status)
+        assert_equal({ 'X-Sabre-Temp' => ['true'] }, @response.headers)
+
+        request = Tilia::Http::Request.new('GET', '/._testput.txt')
+
+        @server.http_request = request
+        @server.exec
+
+        assert_equal(200, @response.status)
+        assert_equal(
+          {
+            'X-Sabre-Temp' => ['true'],
+            'Content-Length' => [16],
+            'Content-Type' => ['application/octet-stream']
+          },
+          @response.headers
+        )
+
+        assert_equal('Testing new file', @response.body_as_string)
+      end
+
+      def test_lock_non_existant
+        Dir.mkdir(::File.join(@temp_dir, 'locksdir'))
+        locks_backend = Tilia::Dav::Locks::Backend::File.new(::File.join(@temp_dir, 'locks'))
+        locks_plugin = Tilia::Dav::Locks::Plugin.new(locks_backend)
+        @server.add_plugin(locks_plugin)
+
+        # mimicking an OS/X resource fork
+        request = Tilia::Http::Request.new('LOCK', '/._testput.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(201, @response.status)
+        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('true', @response.header('X-Sabre-Temp'))
+
+        refute(::File.exist?(::File.join(@temp_dir, '._testlock.txt')), '_testlock.txt should not exist in the regular file structure.')
+      end
+
+      def test_put_delete
+        # mimicking an OS/X resource fork
+        request = Tilia::Http::Request.new('PUT', '/._testput.txt', [], 'Testing new file')
+
+        @server.http_request = request
+        @server.exec
+
+        assert_equal(nil, @response.body)
+        assert_equal(201, @response.status)
+        assert_equal({ 'X-Sabre-Temp' => ['true'] }, @response.headers)
+
+        request = Tilia::Http::Request.new('DELETE', '/._testput.txt')
+        @server.http_request = request
+        @server.exec
+
+        assert_equal(204, @response.status, "Incorrect status code received. Full body:\n#{@response.body}")
+        assert_equal({ 'X-Sabre-Temp' => ['true'] }, @response.headers)
+
+        assert_equal(nil, @response.body)
+      end
+
+      def test_put_propfind
+        # mimicking an OS/X resource fork
+        request = Tilia::Http::Request.new('PUT', '/._testput.txt', [], 'Testing new file')
+        @server.http_request = request
+        @server.exec
+
+        assert_equal(nil, @response.body)
+        assert_equal(201, @response.status)
+        assert_equal({ 'X-Sabre-Temp' => ['true'] }, @response.headers)
+
+        request = Tilia::Http::Request.new('PROPFIND', '/._testput.txt')
+
+        @server.http_request = request
+        @server.exec
+
+        assert_equal(207, @response.status, "Incorrect status code returned. Body: #{@response.body}")
+        assert_equal(
+          {
+            'X-Sabre-Temp' => ['true'],
+            'Content-Type' => ['application/xml; charset=utf-8']
+          },
+          @response.headers
+        )
+
+        body = @response.body.gsub(/xmlns(:[A-Za-z0-9_])?=("|')DAV:("|')/) { "xmlns#{Regexp.last_match(1)}=\"urn:DAV\"" }
+
+        xml = LibXML::XML::Document.string(body)
+
+        data = xml.find_first('/d:multistatus/d:response/d:href')
+        assert_equal('/._testput.txt', data.content, 'href element should have been /._testput.txt')
+
+        data = xml.find('/d:multistatus/d:response/d:propstat/d:prop/d:resourcetype')
+        assert_equal(1, data.size)
+      end
+    end
+  end
+end

data/test/dav/test_plugin.rb

@@ -0,0 +1,24 @@
+module Tilia
+  module Dav
+    class TestPlugin < ServerPlugin
+      attr_accessor :saved_before_method
+
+      def features
+        %w(drinking)
+      end
+
+      def http_methods(_uri)
+        %w(BEER WINE)
+      end
+
+      def setup(server)
+        server.on('beforeMethod', method(:before_method))
+      end
+
+      def before_method(request, _response)
+        @saved_before_method = request.method
+        true
+      end
+    end
+  end
+end

data/test/dav/tree_test.rb

@@ -0,0 +1,201 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class TreeTest < Minitest::Test
+      def setup
+        @tree = Tilia::Dav::TreeMock.new
+      end
+
+      def test_node_exists
+        assert(@tree.node_exists('hi'))
+        refute(@tree.node_exists('hello'))
+      end
+
+      def test_copy
+        @tree.copy('hi', 'hi2')
+
+        assert_has_key('hi2', @tree.node_for_path('').new_directories)
+        assert_equal('foobar', @tree.node_for_path('hi/file').get)
+        assert_equal({ 'test1' => 'value' }, @tree.node_for_path('hi/file').properties([]))
+      end
+
+      def test_move
+        @tree.move('hi', 'hi2')
+
+        assert_equal('hi2', @tree.node_for_path('hi').name)
+        assert(@tree.node_for_path('hi').is_renamed)
+      end
+
+      def test_deep_move
+        @tree.move('hi/sub', 'hi2')
+
+        assert_has_key('hi2', @tree.node_for_path('').new_directories)
+        assert(@tree.node_for_path('hi/sub').is_deleted)
+      end
+
+      def test_delete
+        @tree.delete('hi')
+        assert(@tree.node_for_path('hi').is_deleted)
+      end
+
+      def test_get_children
+        children = @tree.children('')
+        assert_equal(2, children.size)
+        assert_equal('hi', children[0].name)
+      end
+
+      def test_get_multiple_nodes
+        result = @tree.multiple_nodes(['hi/sub', 'hi/file'])
+        assert_has_key('hi/sub', result)
+        assert_has_key('hi/file', result)
+
+        assert_equal('sub', result['hi/sub'].name)
+        assert_equal('file', result['hi/file'].name)
+      end
+
+      def test_get_multiple_nodes2
+        result = @tree.multiple_nodes(['multi/1', 'multi/2'])
+        assert_has_key('multi/1', result)
+        assert_has_key('multi/2', result)
+      end
+    end
+
+    class TreeMock < Tree
+      def initialize
+        @nodes = []
+
+        file = TreeFileTester.new('file')
+        file.properties = { 'test1' => 'value' }
+        file.data = 'foobar'
+
+        super(
+          TreeDirectoryTester.new(
+            'root', [
+              TreeDirectoryTester.new(
+                'hi',
+                [
+                  TreeDirectoryTester.new('sub'),
+                  file
+                ]
+              ),
+              TreeMultiGetTester.new(
+                'multi',
+                [
+                  TreeFileTester.new('1'),
+                  TreeFileTester.new('2'),
+                  TreeFileTester.new('3')
+                ]
+              )
+            ]
+          )
+        )
+      end
+    end
+
+    class TreeDirectoryTester < SimpleCollection
+      attr_accessor :new_directories
+      attr_accessor :new_files
+      attr_accessor :is_deleted
+      attr_accessor :is_renamed
+
+      def initialize(*args)
+        @new_directories = {}
+        @new_files = {}
+        @is_deleted = false
+        @is_renamed = false
+        super(*args)
+      end
+
+      def create_directory(name)
+        @new_directories[name] = true
+      end
+
+      def create_file(name, data = nil)
+        @new_files[name] = data
+      end
+
+      def child(name)
+        return TreeDirectoryTester.new(name) if @new_directories.key?(name)
+        return TreeFileTester.new(name, @new_files[name]) if @new_files[name]
+        super(name)
+      end
+
+      def child_exists(name)
+        !!child(name)
+      end
+
+      def delete
+        @is_deleted = true
+      end
+
+      def name=(name)
+        @is_renamed = true
+        @name = name
+      end
+    end
+
+    class TreeFileTester < File
+      include IProperties
+
+      attr_accessor :name
+      attr_accessor :data
+      attr_accessor :properties
+
+      def initialize(name, data = nil)
+        @name = name
+        data = 'bla' if data.nil?
+        @data = data
+      end
+
+      attr_reader :name
+
+      def get
+        @data
+      end
+
+      def properties(_properties)
+        @properties
+      end
+
+      # Updates properties on this node.
+      #
+      # This method received a PropPatch object, which contains all the
+      # information about the update.
+      #
+      # To update specific properties, call the 'handle' method on this object.
+      # Read the PropPatch documentation for more information.
+      #
+      # @param array mutations
+      # @return bool|array
+      def prop_patch(prop_patch)
+        @properties = prop_patch.mutations
+        prop_patch.remaining_result_code = 200
+      end
+    end
+
+    class TreeMultiGetTester < TreeDirectoryTester
+      include IMultiGet
+
+      # This method receives a list of paths in it's first argument.
+      # It must return an array with Node objects.
+      #
+      # If any children are not found, you do not have to return them.
+      #
+      # @return array
+      def multiple_children(paths)
+        result = []
+        paths.each do |path|
+          begin
+            child = child(path)
+            result << child
+          rescue Exception::NotFound => e
+            # Do nothing
+          end
+        end
+
+        result
+      end
+    end
+  end
+end