src/server/plugins/postgresql/pgtest.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2022 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <inttypes.h>

#include "../../util/util.h"
#include "../../test/testutils.h"
#include "../../test/webdav.h"
#include "../../public/nsapi.h"
#include "../../public/webdav.h"
#include "../../webdav/webdav.h"

#include <cx/string.h>
#include <cx/buffer.h>

#include "pgtest.h"
#include "vfs.h"
#include "webdav.h"

#include <libpq-fe.h>

#define xstreq(a,b) xmlStrEqual(BAD_CAST a, BAD_CAST b)

#define MAP_GET(map, key) cxMapGet(map, cx_hash_key_str(key))
#define MAP_PUT(map, key, value) cxMapPut(map, cx_hash_key_str(key), value)

static char *pg_connstr = "postgresql://localhost/test1";
static int abort_pg_tests = 0;
static PGconn *test_connection;
static ResourceData resdata;
static PgRepository test_repo;

void debug_print_resources(void) {
    PGresult *result = PQexec(test_connection, "select * from Resource;");
    int n = PQntuples(result);
    printf("\nntuples: %d\n-----------------------------------------------\n", n);
    printf("%10s  %10s  %s\n", "resource_id", "parent_id", "nodename");
    for(int i=0;i<n;i++) {
        char *res_id = PQgetvalue(result, i, 0);
        char *parent_id = PQgetvalue(result, i, 1);
        char *nodename = PQgetvalue(result, i, 2);
        printf("%10s  %10s  %s\n", res_id, parent_id, nodename);
    }
    printf("\n");
}

static void test_root_lookup(void) {
    memset(&test_repo,  0, sizeof(PgRepository));
    
    int64_t root_id = -1;
    int err = pg_lookup_root(&resdata, "root", &root_id);
    test_repo.root_resource_id = root_id;
    
    if(err || root_id < 0) {
        abort_pg_tests = 1;
    }
}

void register_pg_tests(int argc, char **argv, CxTestSuite *suite) {
    
    test_connection = PQconnectdb(pg_connstr);
    if(!test_connection) {
        abort_pg_tests = 1;
    }
    
    if(PQstatus(test_connection) != CONNECTION_OK) {
        abort_pg_tests = 1;
    }
    
    resdata.data = test_connection;
    test_root_lookup();
    
    cx_test_register(suite, test_pg_conn);
    if(!abort_pg_tests) {
        cx_test_register(suite, test_pg_lookup_root);
        
        cx_test_register(suite, test_pg_vfs_open);
        cx_test_register(suite, test_pg_vfs_io);
        cx_test_register(suite, test_pg_vfs_stat);
        cx_test_register(suite, test_pg_vfs_mkdir);
        cx_test_register(suite, test_pg_vfs_unlink);
        cx_test_register(suite, test_pg_vfs_rmdir);
        
        cx_test_register(suite, test_pg_webdav_create_from_resdata);
        cx_test_register(suite, test_pg_prepare_tests);
        cx_test_register(suite, test_pg_webdav_propfind);
        cx_test_register(suite, test_pg_webdav_propfind_allprop);
        cx_test_register(suite, test_pg_webdav_proppatch_set);
        
        PGresult *result = PQexec(test_connection, "BEGIN");
        PQclear(result);
    }
}

static void parse_response_tag(TestMultistatus *ms, xmlNode *node) {
    // thanks to dav for some of this code
    CxAllocator *a = (CxAllocator*)ms->mp->allocator;
    node = node->children;
    
    cxmutstr href = {NULL, 0};
    CxMap *properties = cxHashMapCreate(a, CX_STORE_POINTERS, 16);
    
    while(node) {
        if(node->type == XML_ELEMENT_NODE) {
            if(xstreq(node->name, "href")) {
                xmlNode *href_node = node->children;
                if(href_node->type != XML_TEXT_NODE) {
                    return;
                }
                href = cx_strdup_a(a, cx_str((const char*)href_node->content));
            } else if(xstreq(node->name, "propstat")) {
                xmlNode *n = node->children;
                xmlNode *prop_node = NULL;
                int status_code = 0;
                while(n) {
                    if(n->type == XML_ELEMENT_NODE) {
                        if(xstreq(n->name, "prop")) {
                            prop_node = n;
                        } else if(xstreq(n->name, "status")) {
                            xmlNode *status_node = n->children;
                            if(status_node->type != XML_TEXT_NODE) {
                                return;
                            }
                            cxmutstr status_str = cx_mutstr((char*)status_node->content);
                            if(status_str.length < 13) {
                                return;
                            }
                            status_str = cx_strsubsl_m(status_str, 9, 3);
                            cxmutstr status_s = cx_strdup(cx_strcast(status_str));
                            status_code = atoi(status_s.ptr);
                            free(status_s.ptr);
                        }
                    }    
                    n = n->next;
                }
                
                n = prop_node->children;
                while(n) {
                    if(n->type == XML_ELEMENT_NODE) {
                        TestProperty *property = cxCalloc(ms->mp->allocator, 1, sizeof(TestProperty));
                        if(n->ns) {
                            property->prefix = n->ns->prefix ? cx_strdup_a(a, cx_str((const char*)n->ns->prefix)).ptr : NULL;
                            property->namespace = n->ns->href ? cx_strdup_a(a, cx_str((const char*)n->ns->href)).ptr : NULL;
                        }
                        property->name = cx_strdup_a(a, cx_str((const char*)n->name)).ptr;
                        property->node = n;
                        property->status = status_code;
                        xmlNode *value = n->children;
                        if(value && value->type == XML_TEXT_NODE) {
                            property->value = cx_strdup_a(a, cx_str((const char*)value->content)).ptr;
                        }
                        if(property->namespace && property->name) {
                            cxmutstr pname = cx_strcat(2, cx_str(property->namespace), cx_str(property->name));
                            cxMapPut(properties, cx_hash_key(pname.ptr, pname.length), property);
                            free(pname.ptr);
                        }
                    }
                    n = n->next;
                }
            }
        }
        node = node->next;
    }
    
    TestResponse *resp = cxMalloc(a, sizeof(TestResponse));
    resp->href = href.ptr;
    resp->properties = properties;
    
    cxMapPut(ms->responses, cx_hash_key(href.ptr, href.length), resp);
}

TestMultistatus* test_parse_multistatus(const char *space, size_t size) {
    xmlDoc *doc = xmlReadMemory(space, size, NULL, NULL, 0);
    if(!doc) {
        return NULL;
    }
    
    CxMempool *mp = cxMempoolCreateSimple(64);
    TestMultistatus *ms = cxMalloc(mp->allocator, sizeof(TestMultistatus));
    ms->doc = doc;
    ms->mp = mp;
    ms->responses = cxHashMapCreate((CxAllocator*)mp->allocator, CX_STORE_POINTERS, 8);
    
    // parse response
    xmlNode *xml_root = xmlDocGetRootElement(doc);
    xmlNode *node = xml_root->children;
    while(node) {
        if(node->type == XML_ELEMENT_NODE) {
            if(xstreq(node->name, "response")) {
                parse_response_tag(ms, node);
            }
        }
        node = node->next;
    }
    
    return ms;
}


void test_multistatus_destroy(TestMultistatus *ms) {
    if(!ms) return;
    xmlFreeDoc(ms->doc);
    cxMempoolFree(ms->mp);
}


CX_TEST(test_pg_conn) {
    char *msg = test_connection ? PQerrorMessage(test_connection) : "no connection";
    
    CX_TEST_DO {
    
        if(abort_pg_tests) {
            int msglen = strlen(msg);
            if(msglen > 0 && msg[msglen-1] == '\n') {
                msglen--;
            }
            fprintf(stdout, "%.*s: ", msglen, msg);
            CX_TEST_ASSERT(1 == 0);
        } else {
            CX_TEST_ASSERT(1 == 1);
        }
    
    }
}

CX_TEST(test_pg_lookup_root) {
    CX_TEST_DO {
        // test already done in test_root_lookup()
        CX_TEST_ASSERT(!abort_pg_tests);
    }
}


static VFS* create_test_pgvfs(Session *sn, Request *rq) { 
    return pg_vfs_create_from_resourcedata(sn, rq, &test_repo, &resdata);
}


CX_TEST(test_pg_vfs_open) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = create_test_pgvfs(sn, rq);
    VFSContext *vfs = vfs_request_context(sn, rq);
    SYS_FILE file;
    
        CX_TEST_DO {

        file = vfs_open(vfs, "/test_notfound1", O_RDONLY);
        CX_TEST_ASSERT(!file);

        file = vfs_open(vfs, "/test_file1", O_RDWR | O_CREAT);
        CX_TEST_ASSERT(file);

        vfs_close(file);
    
    }
    
    testutil_destroy_session(sn);
}

CX_TEST(test_pg_vfs_io) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = create_test_pgvfs(sn, rq);
    VFSContext *vfs = vfs_request_context(sn, rq);
    SYS_FILE file;
    SYS_FILE file2;
    
    CX_TEST_DO {
    
        file = vfs_open(vfs, "/test_f1", O_WRONLY | O_CREAT);
        CX_TEST_ASSERT(file);

        int w = system_fwrite(file, "test1\n", 6);
        CX_TEST_ASSERT(w == 6);
        w = system_fwrite(file, "2", 1);
        CX_TEST_ASSERT(w == 1);

        vfs_close(file);

        file = vfs_open(vfs, "/test_f1", O_RDONLY);
        file2 = vfs_open(vfs, "/test_f2", O_WRONLY | O_CREAT);
        CX_TEST_ASSERT(file);
        CX_TEST_ASSERT(file2);

        char buf[128];
        int r = system_fread(file, buf, 128);
        CX_TEST_ASSERT(r == 7);

        w = system_fwrite(file2, buf, r);
        CX_TEST_ASSERT(w == 7);

        vfs_close(file);
        vfs_close(file2);

        file2 = vfs_open(vfs, "/test_f2", O_RDONLY);

        r = system_fread(file, buf, 128);
        CX_TEST_ASSERT(r == 7);
        CX_TEST_ASSERT(!memcmp(buf, "test1\n2", 7));

        vfs_close(file2);
    
    
    }
    
    testutil_destroy_session(sn);
}

CX_TEST(test_pg_vfs_stat) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = create_test_pgvfs(sn, rq);
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    CX_TEST_DO {
    
        // testdata, content doesn't matter
        char test1[512];
        memset(test1, 'x', 512);
        const int test_len1 = 200;
        const int test_len2 = 432;

        SYS_FILE f1 = vfs_open(vfs, "/test_s1", O_WRONLY|O_CREAT);
        CX_TEST_ASSERT(f1);
        system_fwrite(f1, test1, test_len1);
        vfs_close(f1);

        SYS_FILE f2 = vfs_open(vfs, "/test_s2", O_RDWR|O_CREAT);
        CX_TEST_ASSERT(f2);
        system_fwrite(f2, test1, test_len2);
        vfs_close(f2);

        struct stat st1, st2;
        int r1 = vfs_stat(vfs, "/test_s1", &st1);
        int r2 = vfs_stat(vfs, "/test_s2", &st2);

        CX_TEST_ASSERT(r1 == 0);
        CX_TEST_ASSERT(r2 == 0);

        CX_TEST_ASSERT(st1.st_size == test_len1);
        CX_TEST_ASSERT(st2.st_size == test_len2);

        int testfail = vfs_stat(vfs, "/test_stat_fail", &st1);
        CX_TEST_ASSERT(testfail != 0);
    
    }
    
    testutil_destroy_session(sn);
}

CX_TEST(test_pg_vfs_mkdir) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = create_test_pgvfs(sn, rq);
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    CX_TEST_DO {
    
        struct stat s;

        SYS_FILE f1 = vfs_open(vfs, "/test_mkdir/file", O_WRONLY|O_CREAT);
        CX_TEST_ASSERT(f1 == NULL);

        int r = vfs_mkdir(vfs, "/test_mkdir");
        CX_TEST_ASSERT(r == 0);

        r = vfs_stat(vfs, "/test_mkdir", &s);
        CX_TEST_ASSERT(r == 0);

        CX_TEST_ASSERT(S_ISDIR(s.st_mode));

        f1 = vfs_open(vfs, "/test_mkdir/file", O_WRONLY|O_CREAT);
        vfs_close(f1);
        CX_TEST_ASSERT(f1);

        r = vfs_stat(vfs, "/test_mkdir/file", &s);
        CX_TEST_ASSERT(r == 0);

        r = vfs_mkdir(vfs, "/test_mkdir/test_sub");
        CX_TEST_ASSERT(r == 0);

        r = vfs_stat(vfs, "/test_mkdir/test_sub", &s);
        CX_TEST_ASSERT(r == 0);
        CX_TEST_ASSERT(S_ISDIR(s.st_mode));

        r = vfs_mkdir(vfs, "/test_mkdir/test_sub/test_sub2/");
        CX_TEST_ASSERT(r == 0);

        r = vfs_stat(vfs, "/test_mkdir/test_sub/test_sub2/", &s);
        CX_TEST_ASSERT(r == 0);
        CX_TEST_ASSERT(S_ISDIR(s.st_mode));
    
    }
    
    testutil_destroy_session(sn);
}

CX_TEST(test_pg_vfs_unlink) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = create_test_pgvfs(sn, rq);
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    CX_TEST_DO {
    
        SYS_FILE f1 = vfs_open(vfs, "/test_unlink1", O_WRONLY|O_CREAT);
        CX_TEST_ASSERT(f1);
        system_fwrite(f1, "test", 4);

        PgFile *pgfile = f1->data;
        Oid oid = pgfile->oid;

        vfs_close(f1);

        int r = vfs_unlink(vfs, "/test_unlink1");
        CX_TEST_ASSERT(r == 0);

        f1 = vfs_open(vfs, "/test_unlink1", O_RDONLY);
        CX_TEST_ASSERT(f1 == NULL);

        PGresult *result = PQexec(test_connection, "savepoint sp;");
        PQclear(result);
        int pgfd = lo_open(test_connection, oid, INV_READ);
        CX_TEST_ASSERT(pgfd < 0);
        result = PQexec(test_connection, "rollback to savepoint sp;");
        PQclear(result);

        r = vfs_unlink(vfs, "/test_unlink1");
        CX_TEST_ASSERT(r);
    
    }
    
    testutil_destroy_session(sn);
}

CX_TEST(test_pg_vfs_rmdir) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = create_test_pgvfs(sn, rq);
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    PQexec(test_connection, "delete from Resource where parent_id is not null;");
    
    CX_TEST_DO {
    
        int r;
        SYS_FILE f1;

        // prepare some dirs/files
        r = vfs_mkdir(vfs, "/rmdir_test");
        CX_TEST_ASSERT(r == 0);
        r = vfs_mkdir(vfs, "/rmdir_test/subdir1");
        CX_TEST_ASSERT(r == 0);
        r = vfs_mkdir(vfs, "/rmdir_test/subdir2");
        CX_TEST_ASSERT(r == 0);

        f1 = vfs_open(vfs, "/rmdir_test/subdir2/file", O_CREAT|O_WRONLY);
        CX_TEST_ASSERT(f1);
        vfs_close(f1);

        // test rmdir
        r = vfs_rmdir(vfs, "/rmdir_test/subdir1");
        CX_TEST_ASSERT(r == 0);

        r = vfs_rmdir(vfs, "/rmdir_test/subdir2");
        CX_TEST_ASSERT(r != 0);

        r = vfs_unlink(vfs, "/rmdir_test/subdir2/file");
        CX_TEST_ASSERT(r == 0);

        r = vfs_rmdir(vfs, "/rmdir_test/subdir2");
        CX_TEST_ASSERT(r == 0);

    }
    
    testutil_destroy_session(sn);
}

/* ----------------------------- WebDAV tests ----------------------------- */


static WebdavBackend* create_test_pgdav(Session *sn, Request *rq) {
    return pg_webdav_create_from_resdata(sn, rq, &test_repo, &resdata);
}

CX_TEST(test_pg_webdav_create_from_resdata) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PROPFIND", "/");
    
    CX_TEST_DO {
    
        WebdavBackend *dav = create_test_pgdav(sn, rq);
        CX_TEST_ASSERT(dav);
    
    }
}

CX_TEST(test_pg_prepare_tests) {
    Session *sn = testutil_session();
    Request *rq = testutil_request(sn->pool, "PUT", "/");
    rq->vfs = create_test_pgvfs(sn, rq);
    VFSContext *vfs = vfs_request_context(sn, rq);
    
    CX_TEST_DO {
    
        vfs_mkdir(vfs, "/propfind");
        vfs_mkdir(vfs, "/proppatch");
        SYS_FILE f1;

        int64_t res1_id, res2_id;

        f1 = vfs_open(vfs, "/propfind/res1", O_WRONLY|O_CREAT);
        CX_TEST_ASSERT(f1);
        res1_id = ((PgFile*)f1->data)->resource_id;
        vfs_close(f1);

        f1 = vfs_open(vfs, "/propfind/res2", O_WRONLY|O_CREAT);
        CX_TEST_ASSERT(f1);
        res2_id = ((PgFile*)f1->data)->resource_id;
        vfs_close(f1);

        f1 = vfs_open(vfs, "/propfind/res3", O_WRONLY|O_CREAT);
        CX_TEST_ASSERT(f1);
        vfs_close(f1);

        int r = vfs_mkdir(vfs, "/propfind/sub");
        CX_TEST_ASSERT(r == 0);

        f1 = vfs_open(vfs, "/propfind/sub/res4", O_WRONLY|O_CREAT);
        CX_TEST_ASSERT(f1);
        vfs_close(f1);

        f1 = vfs_open(vfs, "/proppatch/pp1", O_WRONLY|O_CREAT);
        CX_TEST_ASSERT(f1);
        vfs_close(f1);

        // 2 properties for res1
        char idstr[32];
        snprintf(idstr, 32, "%" PRId64, res1_id);
        const char* params[1] = { idstr };
        PGresult *result = PQexecParams(
                test_connection,
                "insert into Property(resource_id, prefix, xmlns, pname, pvalue) values ($1, 'x', 'http://example.com/', 'test', 'testvalue');",
                1,     // number of parameters
                NULL,
                params, // parameter value
                NULL,
                NULL,
                0);    // 0: result in text format

        CX_TEST_ASSERT(PQresultStatus(result) == PGRES_COMMAND_OK);
        PQclear(result);

        result = PQexecParams(
                test_connection,
                "insert into Property(resource_id, prefix, xmlns, pname, pvalue) values ($1, 'x', 'http://example.com/', 'prop2', 'value2');",
                1,     // number of parameters
                NULL,
                params, // parameter value
                NULL,
                NULL,
                0);    // 0: result in text format

        CX_TEST_ASSERT(PQresultStatus(result) == PGRES_COMMAND_OK);
        PQclear(result);

        // 1 property for res2
        snprintf(idstr, 32, "%" PRId64, res2_id);
        result = PQexecParams(
                test_connection,
                "insert into Property(resource_id, prefix, xmlns, pname, pvalue) values ($1, 'x', 'http://example.com/', 'test', 'res2test');",
                1,     // number of parameters
                NULL,
                params, // parameter value
                NULL,
                NULL,
                0);    // 0: result in text format

        CX_TEST_ASSERT(PQresultStatus(result) == PGRES_COMMAND_OK);
        PQclear(result);
    
    }
    
    testutil_destroy_session(sn);
}

CX_TEST(test_pg_webdav_propfind) {
    Session *sn;
    Request *rq; 
    TestIOStream *st;
    pblock *pb;
    
    CX_TEST_DO {
    
        // test data:
        //
        // /propfind/
        // /propfind/res1     (2 properties: test, prop2)
        // /propfind/res2     (1 property: test)
        // /propfind/res3
        // /propfind/sub
        // /propfind/sub/res4

        int ret;
        // Test 1
        init_test_webdav_method(&sn, &rq, &st, &pb, "PROPFIND", "/propfind/", PG_TEST_PROPFIND1);
        rq->davCollection = create_test_pgdav(sn, rq);
        pblock_nvinsert("depth", "0", rq->headers);

        ret = webdav_propfind(pb, sn, rq);

        CX_TEST_ASSERT(ret == REQ_PROCEED);

        TestMultistatus *ms = test_parse_multistatus(st->buf->space, st->buf->size);
        CX_TEST_ASSERT(ms);

        TestResponse *r1 = MAP_GET(ms->responses, "/propfind/");
        CX_TEST_ASSERT(r1);

        CX_TEST_ASSERT(cxMapSize(ms->responses) == 1);

        TestProperty *p = MAP_GET(r1->properties, "DAV:resourcetype");
        CX_TEST_ASSERT(p);
        CX_TEST_ASSERT(p->status == 200);

        p = MAP_GET(r1->properties, "DAV:getlastmodified");
        CX_TEST_ASSERT(p);
        CX_TEST_ASSERT(p->status == 200);

        testutil_destroy_session(sn);
        test_multistatus_destroy(ms);
        testutil_iostream_destroy(st);


        // Test 2
        init_test_webdav_method(&sn, &rq, &st, &pb, "PROPFIND", "/propfind/", PG_TEST_PROPFIND2);
        rq->davCollection = create_test_pgdav(sn, rq);
        pblock_nvinsert("depth", "1", rq->headers);

        ret = webdav_propfind(pb, sn, rq);

        //printf("\n\n%.*s\n", (int)st->buf->size, st->buf->space);

        CX_TEST_ASSERT(ret == REQ_PROCEED);

        ms = test_parse_multistatus(st->buf->space, st->buf->size);
        CX_TEST_ASSERT(ms);

        r1 = MAP_GET(ms->responses, "/propfind/");
        CX_TEST_ASSERT(r1);

        CX_TEST_ASSERT(cxMapSize(ms->responses) == 5);

        r1 = MAP_GET(ms->responses, "/propfind/res2");
        CX_TEST_ASSERT(r1);

        p = MAP_GET(r1->properties, "http://example.com/test");
        CX_TEST_ASSERT(p);
        CX_TEST_ASSERT(p->status == 200);
        CX_TEST_ASSERT(!strcmp(p->value, "res2test"));


        testutil_destroy_session(sn);
        test_multistatus_destroy(ms);
        testutil_iostream_destroy(st);


        // Test 3
        init_test_webdav_method(&sn, &rq, &st, &pb, "PROPFIND", "/propfind/", PG_TEST_PROPFIND2);
        rq->davCollection = create_test_pgdav(sn, rq);
        pblock_nvinsert("depth", "infinity", rq->headers);

        ret = webdav_propfind(pb, sn, rq);

        //printf("\n\n%.*s\n", (int)st->buf->size, st->buf->space);

        CX_TEST_ASSERT(ret == REQ_PROCEED);

        ms = test_parse_multistatus(st->buf->space, st->buf->size);
        CX_TEST_ASSERT(ms);

        r1 = MAP_GET(ms->responses, "/propfind/");
        CX_TEST_ASSERT(r1);

        CX_TEST_ASSERT(cxMapSize(ms->responses) == 6);


        r1 = MAP_GET(ms->responses, "/propfind/res1");
        CX_TEST_ASSERT(r1);

        p = MAP_GET(r1->properties, "http://example.com/test");
        CX_TEST_ASSERT(p);
        CX_TEST_ASSERT(p->status == 200);
        CX_TEST_ASSERT(!strcmp(p->value, "testvalue"));

        p = MAP_GET(r1->properties, "http://example.com/prop2");
        CX_TEST_ASSERT(p);
        CX_TEST_ASSERT(p->status == 200);
        CX_TEST_ASSERT(!strcmp(p->value, "value2"));


        r1 = MAP_GET(ms->responses, "/propfind/sub/res4");
        CX_TEST_ASSERT(r1);

        testutil_destroy_session(sn);
        test_multistatus_destroy(ms);
        testutil_iostream_destroy(st);
    
    }
}


CX_TEST(test_pg_webdav_propfind_allprop) {
    Session *sn;
    Request *rq; 
    TestIOStream *st;
    pblock *pb;
    
    CX_TEST_DO {
    
        // test data:
        //
        // /propfind/
        // /propfind/res1     (2 properties: test, prop2)
        // /propfind/res2     (1 property: test)
        // /propfind/res3
        // /propfind/sub
        // /propfind/sub/res4

        int ret;
        TestResponse *r1;
        TestProperty *p;
        // Test 1
        init_test_webdav_method(&sn, &rq, &st, &pb, "PROPFIND", "/propfind/", PG_TEST_ALLPROP);
        rq->davCollection = create_test_pgdav(sn, rq);
        pblock_nvinsert("depth", "0", rq->headers);

        ret = webdav_propfind(pb, sn, rq);

        CX_TEST_ASSERT(ret == REQ_PROCEED);

        TestMultistatus *ms = test_parse_multistatus(st->buf->space, st->buf->size);
        CX_TEST_ASSERT(ms);

        r1 = MAP_GET(ms->responses, "/propfind/");
        CX_TEST_ASSERT(r1);
        CX_TEST_ASSERT(cxMapSize(ms->responses) == 1);

        p = MAP_GET(r1->properties, "DAV:resourcetype");
        CX_TEST_ASSERT(r1);

        testutil_destroy_session(sn);
        test_multistatus_destroy(ms);
        testutil_iostream_destroy(st);

        // Test 2
        init_test_webdav_method(&sn, &rq, &st, &pb, "PROPFIND", "/propfind/", PG_TEST_ALLPROP);
        rq->davCollection = create_test_pgdav(sn, rq);
        pblock_nvinsert("depth", "1", rq->headers);

        ret = webdav_propfind(pb, sn, rq);

        //printf("\n\n%.*s\n", (int)st->buf->size, st->buf->space);

        CX_TEST_ASSERT(ret == REQ_PROCEED);

        ms = test_parse_multistatus(st->buf->space, st->buf->size);
        CX_TEST_ASSERT(ms);

        r1 = MAP_GET(ms->responses, "/propfind/");
        CX_TEST_ASSERT(r1);
        CX_TEST_ASSERT(cxMapSize(ms->responses) == 5);

        r1 = MAP_GET(ms->responses, "/propfind/res1");
        CX_TEST_ASSERT(r1);

        p = MAP_GET(r1->properties, "DAV:resourcetype");
        CX_TEST_ASSERT(r1);
        p = MAP_GET(r1->properties, "http://example.com/test");
        CX_TEST_ASSERT(r1);
        p = MAP_GET(r1->properties, "http://example.com/prop2");
        CX_TEST_ASSERT(r1);

        CX_TEST_ASSERT(MAP_GET(ms->responses, "/propfind/res2"));
        CX_TEST_ASSERT(MAP_GET(ms->responses, "/propfind/res3"));
        CX_TEST_ASSERT(MAP_GET(ms->responses, "/propfind/sub/"));

        testutil_destroy_session(sn);
        test_multistatus_destroy(ms);
        testutil_iostream_destroy(st);

        // Test 3
        init_test_webdav_method(&sn, &rq, &st, &pb, "PROPFIND", "/propfind/", PG_TEST_ALLPROP);
        rq->davCollection = create_test_pgdav(sn, rq);
        pblock_nvinsert("depth", "infinity", rq->headers);

        ret = webdav_propfind(pb, sn, rq);

        CX_TEST_ASSERT(ret == REQ_PROCEED);

        ms = test_parse_multistatus(st->buf->space, st->buf->size);
        CX_TEST_ASSERT(ms);

        r1 = MAP_GET(ms->responses, "/propfind/");
        CX_TEST_ASSERT(r1);
        CX_TEST_ASSERT(cxMapSize(ms->responses) == 6);

        r1 = MAP_GET(ms->responses, "/propfind/res1");
        CX_TEST_ASSERT(r1);

        p = MAP_GET(r1->properties, "DAV:resourcetype");
        CX_TEST_ASSERT(r1);
        p = MAP_GET(r1->properties, "http://example.com/test");
        CX_TEST_ASSERT(r1);
        p = MAP_GET(r1->properties, "http://example.com/prop2");
        CX_TEST_ASSERT(r1);

        CX_TEST_ASSERT(MAP_GET(ms->responses, "/propfind/res2"));
        CX_TEST_ASSERT(MAP_GET(ms->responses, "/propfind/res3"));
        CX_TEST_ASSERT(MAP_GET(ms->responses, "/propfind/sub/"));
        CX_TEST_ASSERT(MAP_GET(ms->responses, "/propfind/sub/res4"));

        testutil_destroy_session(sn);
        test_multistatus_destroy(ms);
        testutil_iostream_destroy(st);
    }
}

CX_TEST(test_pg_webdav_proppatch_set) {
    Session *sn;
    Request *rq; 
    TestIOStream *st;
    pblock *pb;
    
    CX_TEST_DO {
    
        // test data:
        //
        // /propfind/
        // /propfind/res1     (2 properties: test, prop2)
        // /propfind/res2     (1 property: test)
        // /propfind/res3
        // /propfind/sub
        // /propfind/sub/res4

        int ret;
        TestResponse *r1;
        TestProperty *p;
        // Test 1
        init_test_webdav_method(&sn, &rq, &st, &pb, "PROPPATCH", "/proppatch/pp1", PG_TEST_PROPPATCH1);
        rq->davCollection = create_test_pgdav(sn, rq);

        ret = webdav_proppatch(pb, sn, rq);
        CX_TEST_ASSERT(ret == REQ_PROCEED);

        //printf("\n\n%.*s\n", (int)st->buf->size, st->buf->space);

        TestMultistatus *ms = test_parse_multistatus(st->buf->space, st->buf->size);
        CX_TEST_ASSERT(ms);

        testutil_destroy_session(sn);
        test_multistatus_destroy(ms);
        testutil_iostream_destroy(st);

        // Test 2: xml property value
        init_test_webdav_method(&sn, &rq, &st, &pb, "PROPPATCH", "/proppatch/pp1", PG_TEST_PROPPATCH2);
        rq->davCollection = create_test_pgdav(sn, rq);

        ret = webdav_proppatch(pb, sn, rq);
        CX_TEST_ASSERT(ret == REQ_PROCEED);

        //printf("\n\n%.*s\n", (int)st->buf->size, st->buf->space);

        ms = test_parse_multistatus(st->buf->space, st->buf->size);
        CX_TEST_ASSERT(ms);

        testutil_destroy_session(sn);
        test_multistatus_destroy(ms);
        testutil_iostream_destroy(st);
    
    }
}