tilia-dav 3.1.0.pre.alpha2

data/test/dav_acl/plugin_update_properties_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+module Tilia
+  module DavAcl
+    class PluginUpdatePropertiesTest < Minitest::Test
+      def test_update_properties_passthrough
+        tree = [Dav::SimpleCollection.new('foo')]
+        server = Dav::ServerMock.new(tree)
+        server.add_plugin(Plugin.new)
+
+        result = server.update_properties(
+          'foo',
+          '{DAV:}foo' => 'bar'
+        )
+
+        expected = { '{DAV:}foo' => 403 }
+
+        assert_equal(expected, result)
+      end
+
+      def test_remove_group_members
+        tree = [MockPrincipal.new('foo', 'foo')]
+        server = Dav::ServerMock.new(tree)
+        server.add_plugin(Plugin.new)
+
+        result = server.update_properties(
+          'foo',
+          '{DAV:}group-member-set' => nil
+        )
+
+        expected = { '{DAV:}group-member-set' => 204 }
+
+        assert_equal(expected, result)
+        assert_equal([], tree[0].group_member_set)
+      end
+
+      def test_set_group_members
+        tree = [MockPrincipal.new('foo', 'foo')]
+        server = Dav::ServerMock.new(tree)
+        server.add_plugin(Plugin.new)
+
+        result = server.update_properties(
+          'foo',
+          '{DAV:}group-member-set' => Dav::Xml::Property::Href.new(['/bar', '/baz'], true)
+        )
+
+        expected = { '{DAV:}group-member-set' => 200 }
+
+        assert_equal(expected, result)
+        assert_equal(['bar', 'baz'], tree[0].group_member_set)
+      end
+
+      def test_set_bad_value
+        tree = [MockPrincipal.new('foo', 'foo')]
+        server = Dav::ServerMock.new(tree)
+        server.add_plugin(Plugin.new)
+
+        assert_raises(Dav::Exception) do
+          server.update_properties(
+            'foo',
+            '{DAV:}group-member-set' => Class.new.new
+          )
+        end
+      end
+
+      def test_set_bad_node
+        tree = [Dav::SimpleCollection.new('foo')]
+        server = Dav::ServerMock.new(tree)
+        server.add_plugin(Plugin.new)
+
+        result = server.update_properties(
+          'foo',
+          '{DAV:}group-member-set' => Dav::Xml::Property::Href.new(['/bar', '/baz'], false)
+        )
+
+        expected = { '{DAV:}group-member-set' => 403 }
+
+        assert_equal(expected, result)
+      end
+    end
+  end
+end

data/test/dav_acl/principal_backend/abstract_sequel_test.rb

@@ -0,0 +1,159 @@
+module Tilia
+  module DavAcl
+    module PrincipalBackend
+      module AbstractSequelTest
+        def sequel
+        end
+
+        def test_construct
+          db = sequel
+          backend = Sequel.new(db)
+          assert_kind_of(Sequel, backend)
+        end
+
+        def test_get_principals_by_prefix
+          db = sequel
+          backend = Sequel.new(db)
+
+          expected = [
+            {
+              'uri' => 'principals/user',
+              '{http://sabredav.org/ns}email-address' => 'user@example.org',
+              '{DAV:}displayname' => 'User'
+            },
+            {
+              'uri' => 'principals/group',
+              '{http://sabredav.org/ns}email-address' => 'group@example.org',
+              '{DAV:}displayname' => 'Group'
+            }
+          ]
+
+          assert_equal(expected, backend.principals_by_prefix('principals'))
+          assert_equal([], backend.principals_by_prefix('foo'))
+        end
+
+        def test_get_principal_by_path
+          db = sequel
+          backend = Sequel.new(db)
+
+          expected = {
+            'id' => 1,
+            'uri' => 'principals/user',
+            '{http://sabredav.org/ns}email-address' => 'user@example.org',
+            '{DAV:}displayname' => 'User'
+          }
+
+          assert_equal(expected, backend.principal_by_path('principals/user'))
+          assert_nil(backend.principal_by_path('foo'))
+        end
+
+        def test_get_group_member_set
+          db = sequel
+          backend = Sequel.new(db)
+          expected = ['principals/user']
+
+          assert_equal(expected, backend.group_member_set('principals/group'))
+        end
+
+        def test_get_group_membership
+          db = sequel
+          backend = Sequel.new(db)
+          expected = ['principals/group']
+
+          assert_equal(expected, backend.group_membership('principals/user'))
+        end
+
+        def test_set_group_member_set
+          db = sequel
+
+          # Start situation
+          backend = Sequel.new(db)
+          assert_equal(['principals/user'], backend.group_member_set('principals/group'))
+
+          # Removing all principals
+          backend.update_group_member_set('principals/group', [])
+          assert_equal([], backend.group_member_set('principals/group'))
+
+          # Adding principals again
+          backend.update_group_member_set('principals/group', ['principals/user'])
+          assert_equal(['principals/user'], backend.group_member_set('principals/group'))
+        end
+
+        def test_search_principals
+          db = sequel
+
+          backend = Sequel.new(db)
+
+          result = backend.search_principals('principals', '{DAV:}blabla' => 'foo')
+          assert_equal([], result)
+
+          result = backend.search_principals('principals', '{DAV:}displayname' => 'ou')
+          assert_equal(['principals/group'], result)
+
+          result = backend.search_principals('principals', '{DAV:}displayname' => 'UsEr', '{http://sabredav.org/ns}email-address' => 'USER@EXAMPLE')
+          assert_equal(['principals/user'], result)
+
+          result = backend.search_principals('mom', '{DAV:}displayname' => 'UsEr', '{http://sabredav.org/ns}email-address' => 'USER@EXAMPLE')
+          assert_equal([], result)
+        end
+
+        def test_update_principal
+          db = sequel
+          backend = Sequel.new(db)
+
+          prop_patch = Dav::PropPatch.new(
+            '{DAV:}displayname' => 'pietje'
+          )
+
+          backend.update_principal('principals/user', prop_patch)
+          result = prop_patch.commit
+
+          assert(result)
+
+          assert_equal(
+            {
+              'id' => 1,
+              'uri' => 'principals/user',
+              '{DAV:}displayname' => 'pietje',
+              '{http://sabredav.org/ns}email-address' => 'user@example.org'
+            },
+            backend.principal_by_path('principals/user')
+          )
+        end
+
+        def test_update_principal_unknown_field
+          db = sequel
+          backend = Sequel.new(db)
+
+          prop_patch = Dav::PropPatch.new(
+            '{DAV:}displayname' => 'pietje',
+            '{DAV:}unknown' => 'foo'
+          )
+
+          backend.update_principal('principals/user', prop_patch)
+          result = prop_patch.commit
+
+          refute(result)
+
+          assert_equal(
+            {
+              '{DAV:}displayname' => 424,
+              '{DAV:}unknown' => 403
+            },
+            prop_patch.result
+          )
+
+          assert_equal(
+            {
+              'id' => 1,
+              'uri' => 'principals/user',
+              '{DAV:}displayname' => 'User',
+              '{http://sabredav.org/ns}email-address' => 'user@example.org'
+            },
+            backend.principal_by_path('principals/user')
+          )
+        end
+      end
+    end
+  end
+end

data/test/dav_acl/principal_backend/mock.rb

@@ -0,0 +1,150 @@
+module Tilia
+  module DavAcl
+    module PrincipalBackend
+      class Mock < AbstractBackend
+        attr_accessor :group_members
+        attr_accessor :principals
+
+        def initialize(principals = nil)
+          @group_members = {}
+          @principals = principals
+
+          unless principals
+            @principals = [
+              {
+                'uri'                                   => 'principals/user1',
+                '{DAV:}displayname'                     => 'User 1',
+                '{http://sabredav.org/ns}email-address' => 'user1.sabredav@sabredav.org',
+                '{http://sabredav.org/ns}vcard-url'     => 'addressbooks/user1/book1/vcard1.vcf'
+              },
+              {
+                'uri'               => 'principals/admin',
+                '{DAV:}displayname' => 'Admin'
+              },
+              {
+                'uri'                                   => 'principals/user2',
+                '{DAV:}displayname'                     => 'User 2',
+                '{http://sabredav.org/ns}email-address' => 'user2.sabredav@sabredav.org'
+              }
+            ]
+          end
+        end
+
+        def principals_by_prefix(prefix)
+          prefix = prefix.gsub(%r{^/+|/+$}, '')
+          prefix << '/' unless prefix.blank?
+
+          to_return = []
+          @principals.each do |principal|
+            next if !prefix.blank? && principal['uri'].index(prefix) != 0
+            to_return << principal
+          end
+
+          to_return
+        end
+
+        def add_principal(principal)
+          @principals << principal
+        end
+
+        def principal_by_path(path)
+          principals_by_prefix('principals').each do |principal|
+            return principal if principal['uri'] == path
+          end
+          nil
+        end
+
+        def search_principals(prefix_path, search_properties, test = 'allof')
+          matches = []
+
+          principals_by_prefix(prefix_path).each do |principal|
+            skip = false
+            search_properties.each do |key, value|
+              unless principal.key?(key)
+                skip = true
+                break
+              end
+              unless principal[key].downcase.index(value.downcase)
+                skip = true
+                break
+              end
+
+              # We have a match for this searchProperty!
+              if test == 'allof'
+                next
+              else
+                break
+              end
+            end
+            next if skip
+
+            matches << principal['uri']
+          end
+
+          matches
+        end
+
+        def group_member_set(path)
+          @group_members.key?(path) ? @group_members[path] : []
+        end
+
+        def group_membership(path)
+          membership = []
+          @group_members.each do |group, members|
+            membership << group if members.include?(path)
+          end
+          membership
+        end
+
+        def update_group_member_set(path, members)
+          @group_members[path] = members
+        end
+
+        # Updates one ore more webdav properties on a principal.
+        #
+        # The list of mutations is stored in a Sabre\DAV\PropPatch object.
+        # To do the actual updates, you must tell this object which properties
+        # you're going to process with the handle method.
+        #
+        # Calling the handle method is like telling the PropPatch object "I
+        # promise I can handle updating this property".
+        #
+        # Read the PropPatch documenation for more info and examples.
+        #
+        # @param string path
+        # @param \Sabre\DAV\PropPatch prop_patch
+        def update_principal(path, prop_patch)
+          value = nil
+          principal_index = nil
+          principal = nil
+
+          @principals.each_with_index do |value, i|
+            principal_index = i
+            if value['uri'] == path
+              principal = value
+              break
+            end
+          end
+
+          return nil unless principal
+
+          prop_patch.handle_remaining(
+            lambda do |mutations|
+              mutations.each do |prop, value|
+                if value.nil? && principal.key?(prop)
+                  principal.delete(prop)
+                else
+                  principal[prop] = value
+                end
+              end
+
+              @principals[principal_index] = principal
+
+              return true
+            end
+          )
+        end
+      end
+    end
+  end
+end

data/test/dav_acl/principal_backend/sequel_my_sql_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Tilia
+  module DavAcl
+    module PrincipalBackend
+      class SequelMySqlTest < Minitest::Test
+        include AbstractSequelTest
+
+        def sequel
+          db = TestUtil.mysql
+          db.run('DROP TABLE IF EXISTS principals')
+          db.run(<<QUERY
+create table principals (
+  id integer unsigned not null primary key auto_increment,
+  uri varchar(50),
+  email varchar(80),
+  displayname VARCHAR(80),
+  vcardurl VARCHAR(80),
+  unique(uri)
+) #{TestUtil.mysql_engine}
+QUERY
+                )
+          db.run("INSERT INTO principals (uri,email,displayname) VALUES ('principals/user','user@example.org','User')")
+          db.run("INSERT INTO principals (uri,email,displayname) VALUES ('principals/group','group@example.org','Group')")
+
+          db.run('DROP TABLE IF EXISTS groupmembers')
+          db.run(<<QUERY
+CREATE TABLE groupmembers (
+  id INTEGER UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,
+  principal_id INTEGER UNSIGNED NOT NULL,
+  member_id INTEGER UNSIGNED NOT NULL,
+  UNIQUE(principal_id, member_id)
+)  #{TestUtil.mysql_engine}
+QUERY
+                )
+          db.run('INSERT INTO groupmembers (principal_id,member_id) VALUES (2,1)')
+
+          db
+        end
+      end
+    end
+  end
+end

data/test/dav_acl/principal_backend/sequel_sqlite_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Tilia
+  module DavAcl
+    module PrincipalBackend
+      class SequelSqliteTest < Minitest::Test
+        include AbstractSequelTest
+
+        def sequel
+          db = TestUtil.sqlite
+          db.run('CREATE TABLE principals (id INTEGER PRIMARY KEY ASC, uri TEXT, email VARCHAR(80), displayname VARCHAR(80))')
+          db.run('INSERT INTO principals VALUES (1, "principals/user","user@example.org","User")')
+          db.run('INSERT INTO principals VALUES (2, "principals/group","group@example.org","Group")')
+
+          db.run(<<SQL
+CREATE TABLE groupmembers (
+  id INTEGER PRIMARY KEY ASC,
+  principal_id INT,
+  member_id INT,
+  UNIQUE(principal_id, member_id)
+)
+SQL
+                )
+          db.run('INSERT INTO groupmembers (principal_id,member_id) VALUES (2,1)')
+
+          db
+        end
+      end
+    end
+  end
+end