tilia-dav 3.1.0.pre.alpha2

data/test/dav/uuid_util_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    class UuidUtilTest < Minitest::Test
+      def test_validate_uuid
+        assert(Tilia::Dav::UuidUtil.validate_uuid('11111111-2222-3333-4444-555555555555'))
+        refute(Tilia::Dav::UuidUtil.validate_uuid(' 11111111-2222-3333-4444-555555555555'))
+        assert(Tilia::Dav::UuidUtil.validate_uuid('ffffffff-2222-3333-4444-555555555555'))
+        refute(Tilia::Dav::UuidUtil.validate_uuid('fffffffg-2222-3333-4444-555555555555'))
+      end
+    end
+  end
+end

data/test/dav/xml/element/prop_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Xml
+      module Element
+        class PropTest < XmlTester
+          def assert_decode_prop(input, expected, element_map = {})
+            element_map['{DAV:}root'] = Tilia::Dav::Xml::Element::Prop
+
+            result = parse(input, element_map)
+            assert_kind_of(Hash, result)
+            assert_instance_equal(expected, result['value'])
+          end
+
+          def test_deserialize_simple
+            input = <<XML
+<?xml version="1.0"?>
+<root xmlns="DAV:">
+  <foo>bar</foo>
+</root>
+XML
+
+            expected = { '{DAV:}foo' => 'bar' }
+
+            assert_decode_prop(input, expected)
+          end
+
+          def test_deserialize_empty
+            input = <<XML
+<?xml version="1.0"?>
+<root xmlns="DAV:" />
+XML
+
+            expected = {}
+
+            assert_decode_prop(input, expected)
+          end
+
+          def test_deserialize_complex
+            input = <<XML
+<?xml version="1.0"?>
+<root xmlns="DAV:">
+  <foo><no>yes</no></foo>
+</root>
+XML
+
+            expected = { '{DAV:}foo' => Tilia::Dav::Xml::Property::Complex.new('<no xmlns="DAV:">yes</no>') }
+
+            assert_decode_prop(input, expected)
+          end
+
+          def test_deserialize_custom
+            input = <<XML
+<?xml version="1.0"?>
+<root xmlns="DAV:">
+  <foo><href>/hello</href></foo>
+</root>
+XML
+
+            expected = { '{DAV:}foo' => Tilia::Dav::Xml::Property::Href.new('/hello', false) }
+
+            element_map = { '{DAV:}foo' => Tilia::Dav::Xml::Property::Href }
+
+            assert_decode_prop(input, expected, element_map)
+          end
+
+          def test_deserialize_custom_callback
+            input = <<XML
+<?xml version="1.0"?>
+<root xmlns="DAV:">
+  <foo>blabla</foo>
+</root>
+XML
+
+            expected = { '{DAV:}foo' => 'zim' }
+
+            element_map = {
+              '{DAV:}foo' => lambda do |reader|
+                reader.next
+                return 'zim'
+              end
+            }
+
+            assert_decode_prop(input, expected, element_map)
+          end
+
+          def test_deserialize_custom_bad
+            input = <<XML
+<?xml version="1.0"?>
+<root xmlns="DAV:">
+  <foo>blabla</foo>
+</root>
+XML
+
+            expected = {}
+
+            element_map = { '{DAV:}foo' => 'idk?' }
+
+            assert_raises(RuntimeError) { assert_decode_prop(input, expected, element_map) }
+          end
+
+          def test_deserialize_custom_bad_obj
+            input = <<XML
+<?xml version="1.0"?>
+<root xmlns="DAV:">
+  <foo>blabla</foo>
+</root>
+XML
+
+            expected = {}
+
+            element_map = { '{DAV:}foo' => Class.new }
+
+            assert_raises(RuntimeError) { assert_decode_prop(input, expected, element_map) }
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/xml/element/response_test.rb

@@ -0,0 +1,202 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Xml
+      module Element
+        class ResponseTest < XmlTester
+          def test_simple
+            inner_props = {
+              200 => { '{DAV:}displayname' => 'my file' },
+              404 => { '{DAV:}owner' => nil }
+            }
+
+            property = Tilia::Dav::Xml::Element::Response.new('uri', inner_props)
+
+            assert_equal('uri', property.href)
+            assert_equal(inner_props, property.response_properties)
+          end
+
+          def test_serialize
+            inner_props = {
+              200 => { '{DAV:}displayname' => 'my file' },
+              404 => { '{DAV:}owner' => nil }
+            }
+
+            property = Tilia::Dav::Xml::Element::Response.new('uri', inner_props)
+
+            xml = write('{DAV:}root' => { '{DAV:}response' => property })
+
+            expected = <<XML
+<?xml version="1.0"?>
+<d:root xmlns:d="DAV:">
+  <d:response>
+    <d:href>/uri</d:href>
+    <d:propstat>
+      <d:prop>
+        <d:displayname>my file</d:displayname>
+      </d:prop>
+      <d:status>HTTP/1.1 200 OK</d:status>
+    </d:propstat>
+    <d:propstat>
+      <d:prop>
+        <d:owner/>
+      </d:prop>
+      <d:status>HTTP/1.1 404 Not Found</d:status>
+    </d:propstat>
+  </d:response>
+</d:root>
+XML
+            assert_xml_equal(expected, xml)
+          end
+
+          # This one is specifically for testing properties with no namespaces, which is legal xml
+          def test_serialize_empty_namespace
+            inner_props = {
+              200 => { '{}propertyname' => 'value' }
+            }
+
+            property = Tilia::Dav::Xml::Element::Response.new('uri', inner_props)
+
+            xml = write('{DAV:}root' => { '{DAV:}response' => property })
+            expected = <<XML
+<d:root xmlns:d="DAV:">
+  <d:response>
+  <d:href>/uri</d:href>
+  <d:propstat>
+    <d:prop>
+      <propertyname xmlns="">value</propertyname>
+    </d:prop>
+    <d:status>HTTP/1.1 200 OK</d:status>
+  </d:propstat>
+  </d:response>
+</d:root>
+XML
+
+            assert_xml_equal(expected, xml)
+          end
+
+          # This one is specifically for testing properties with no namespaces, which is legal xml
+          def test_serialize_custom_namespace
+            inner_props = {
+              200 => { '{http://sabredav.org/NS/example}propertyname' => 'value' }
+            }
+
+            property = Tilia::Dav::Xml::Element::Response.new('uri', inner_props)
+            xml = write('{DAV:}root' => { '{DAV:}response' => property })
+
+            expected = <<XML
+<?xml version="1.0"?>
+<d:root xmlns:d="DAV:">
+  <d:response>
+    <d:href>/uri</d:href>
+    <d:propstat>
+      <d:prop>
+        <x1:propertyname xmlns:x1="http://sabredav.org/NS/example">value</x1:propertyname>
+      </d:prop>
+    <d:status>HTTP/1.1 200 OK</d:status>
+    </d:propstat>
+  </d:response>
+</d:root>
+XML
+            assert_xml_equal(expected, xml)
+          end
+
+          def test_serialize_complex_property
+            inner_props = {
+              200 => { '{DAV:}link' => Tilia::Dav::Xml::Property::Href.new('http://sabredav.org/', false) }
+            }
+
+            property = Tilia::Dav::Xml::Element::Response.new('uri', inner_props)
+            xml = write('{DAV:}root' => { '{DAV:}response' => property })
+            expected = <<XML
+<?xml version="1.0"?>
+<d:root xmlns:d="DAV:">
+  <d:response>
+    <d:href>/uri</d:href>
+    <d:propstat>
+      <d:prop>
+        <d:link><d:href>http://sabredav.org/</d:href></d:link>
+      </d:prop>
+      <d:status>HTTP/1.1 200 OK</d:status>
+    </d:propstat>
+  </d:response>
+</d:root>
+XML
+            assert_xml_equal(expected, xml)
+          end
+
+          def test_serialize_break
+            inner_props = {
+              200 => { '{DAV:}link' => Class.new }
+            }
+
+            property = Tilia::Dav::Xml::Element::Response.new('uri', inner_props)
+            assert_raises(ArgumentError) { write('{DAV:}root' => { '{DAV:}response' => property }) }
+          end
+
+          def test_deserialize_complex_property
+            xml = <<XML
+<?xml version="1.0"?>
+<d:response xmlns:d="DAV:">
+<d:href>/uri</d:href>
+<d:propstat>
+  <d:prop>
+    <d:foo>hello</d:foo>
+  </d:prop>
+  <d:status>HTTP/1.1 200 OK</d:status>
+</d:propstat>
+</d:response>
+XML
+
+            result = parse(
+              xml,
+              '{DAV:}response' => Tilia::Dav::Xml::Element::Response,
+              '{DAV:}foo' => lambda do |reader|
+                reader.next
+                return 'world'
+              end
+            )
+            expected = Tilia::Dav::Xml::Element::Response.new(
+              '/uri',
+              '200' => { '{DAV:}foo' => 'world' }
+            )
+
+            assert_instance_equal(expected, result['value'])
+          end
+
+          # In the case of {DAV:}prop, a deserializer should never get called, if
+          # the property element is empty.
+          def test_deserialize_complex_property_empty
+            xml = <<XML
+<?xml version="1.0"?>
+<d:response xmlns:d="DAV:">
+  <d:href>/uri</d:href>
+  <d:propstat>
+    <d:prop>
+      <d:foo />
+    </d:prop>
+    <d:status>HTTP/1.1 404 Not Found</d:status>
+  </d:propstat>
+</d:response>
+XML
+
+            result = parse(
+              xml,
+              '{DAV:}response' => Tilia::Dav::Xml::Element::Response,
+              '{DAV:}foo' => lambda do |_reader|
+                fail 'This should never happen'
+              end
+            )
+            expected = Tilia::Dav::Xml::Element::Response.new(
+              '/uri',
+              '404' => { '{DAV:}foo' => nil }
+            )
+
+            assert_instance_equal(expected, result['value'])
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/xml/property/href_test.rb

@@ -0,0 +1,112 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Xml
+      module Property
+        class HrefTest < XmlTester
+          def test_construct
+            href = Tilia::Dav::Xml::Property::Href.new('path')
+            assert_equal('path', href.href)
+          end
+
+          def test_serialize
+            href = Tilia::Dav::Xml::Property::Href.new('path')
+            assert_equal('path', href.href)
+
+            self.context_uri = '/bla/'
+
+            xml = write('{DAV:}anything' => href)
+            expected = <<XML
+<?xml version="1.0"?>
+<d:anything xmlns:d="DAV:"><d:href>/bla/path</d:href></d:anything>
+XML
+            assert_xml_equal(expected, xml)
+          end
+
+          def test_serialize_no_prefix
+            href = Tilia::Dav::Xml::Property::Href.new('path', false)
+            assert_equal('path', href.href)
+
+            xml = write('{DAV:}anything' => href)
+            expected = <<XML
+<?xml version="1.0"?>
+<d:anything xmlns:d="DAV:"><d:href>path</d:href></d:anything>
+XML
+
+            assert_xml_equal(expected, xml)
+          end
+
+          def test_unserialize
+            xml = <<XML
+<?xml version="1.0"?>
+<d:anything xmlns:d="DAV:"><d:href>/bla/path</d:href></d:anything>
+XML
+
+            result = parse(xml, '{DAV:}anything' => Tilia::Dav::Xml::Property::Href)
+
+            href = result['value']
+
+            assert_kind_of(Tilia::Dav::Xml::Property::Href, href)
+
+            assert_equal('/bla/path', href.href)
+          end
+
+          def test_unserialize_incompatible
+            xml = <<XML
+<?xml version="1.0"?>
+<d:anything xmlns:d="DAV:"><d:href2>/bla/path</d:href2></d:anything>
+XML
+            result = parse(xml, '{DAV:}anything' => Tilia::Dav::Xml::Property::Href)
+            href = result['value']
+            assert_nil(href)
+          end
+
+          def test_unserialize_empty
+            xml = <<XML
+<?xml version="1.0"?>
+<d:anything xmlns:d="DAV:"></d:anything>
+XML
+            result = parse(xml, '{DAV:}anything' => Tilia::Dav::Xml::Property::Href)
+            href = result['value']
+            assert_nil(href)
+          end
+
+          # This method tests if hrefs containing & are correctly encoded.
+          def test_serialize_entity
+            href = Tilia::Dav::Xml::Property::Href.new('http://example.org/?a&b', false)
+            assert_equal('http://example.org/?a&b', href.href)
+
+            xml = write('{DAV:}anything' => href)
+            expected = <<XML
+<?xml version="1.0"?>
+<d:anything xmlns:d="DAV:"><d:href>http://example.org/?a&amp;b</d:href></d:anything>
+XML
+            assert_xml_equal(expected, xml)
+          end
+
+          def test_to_html
+            href = Tilia::Dav::Xml::Property::Href.new(
+              [
+                '/foo/bar',
+                'foo/bar',
+                'http://example.org/bar'
+              ]
+            )
+
+            html = Tilia::Dav::Browser::HtmlOutputHelper.new(
+              '/base/',
+              {}
+            )
+
+            expected = '<a href="/foo/bar">/foo/bar</a><br />'
+            expected << '<a href="/base/foo/bar">/base/foo/bar</a><br />'
+            expected << '<a href="http://example.org/bar">http://example.org/bar</a>'
+
+            assert_equal(expected, href.to_html(html))
+          end
+        end
+      end
+    end
+  end
+end