def test_fail_dot_file_put_in_calendar(self):
"""
Make (regular) collection in calendar
"""
calendar_uri = "/calendars/users/wsanchez/dot_file_in_calendar/"
principal = yield self.actualRoot.findPrincipalForAuthID("wsanchez")
request = SimpleStoreRequest(self,
"MKCALENDAR",
calendar_uri,
authPrincipal=principal)
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("MKCALENDAR failed: %s" % (response.code, ))
stream = self.dataPath.child("Holidays").child(
"C318AA54-1ED0-11D9-A5E0-000A958A3252.ics").open()
try:
calendar = str(Component.fromStream(stream))
finally:
stream.close()
event_uri = "/".join([calendar_uri, ".event.ics"])
request = SimpleStoreRequest(self,
"PUT",
event_uri,
authPrincipal=principal)
request.headers.setHeader("content-type", MimeType("text", "calendar"))
request.stream = MemoryStream(calendar)
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.FORBIDDEN:
self.fail("Incorrect response to dot file PUT: %s" %
(response.code, ))
def test_collection_in_calendar(self):
"""
Make (regular) collection in calendar
"""
calendar_uri = "/calendars/users/wsanchez/collection_in_calendar/"
principal = yield self.actualRoot.findPrincipalForAuthID("wsanchez")
request = SimpleStoreRequest(self,
"MKCALENDAR",
calendar_uri,
authPrincipal=principal)
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("MKCALENDAR failed: %s" % (response.code, ))
nested_uri = joinURL(calendar_uri, "nested")
request = SimpleStoreRequest(self,
"MKCOL",
nested_uri,
authPrincipal=principal)
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.FORBIDDEN:
self.fail("Incorrect response to nested MKCOL: %s" %
(response.code, ))
def _test_file_in_calendar(self, what, *work):
"""
Creates a calendar collection, then PUTs a resource into that collection
with the data from given stream and verifies that the response code from the
PUT request matches the given response_code.
"""
calendar_uri = "/calendars/users/wsanchez/testing_calendar/"
principal = yield self.actualRoot.findPrincipalForAuthID("wsanchez")
request = SimpleStoreRequest(self, "MKCALENDAR", calendar_uri, authPrincipal=principal)
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("MKCALENDAR failed: %s" % (response.code,))
c = 0
for stream, response_code in work:
dst_uri = joinURL(calendar_uri, "dst%d.ics" % (c,))
request = SimpleStoreRequest(self, "PUT", dst_uri, authPrincipal=principal)
request.headers.setHeader("if-none-match", "*")
request.headers.setHeader("content-type", MimeType("text", "calendar"))
request.stream = stream
response = yield self.send(request)
response = IResponse(response)
if response.code != response_code:
self.fail("Incorrect response to %s: %s (!= %s)" % (what, response.code, response_code))
c += 1
def calendar_query(self, calendar_uri, query, got_xml, data, no_init):
if not no_init:
response = yield self.send(
SimpleStoreRequest(self,
"MKCALENDAR",
calendar_uri,
authPrincipal=self.authPrincipal))
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("MKCALENDAR failed: %s" % (response.code, ))
if data:
for filename, icaldata in data.iteritems():
request = SimpleStoreRequest(
self,
"PUT",
joinURL(calendar_uri, filename + ".ics"),
headers=Headers({
"content-type":
MimeType.fromString("text/calendar")
}),
authPrincipal=self.authPrincipal)
request.stream = MemoryStream(icaldata)
yield self.send(request)
else:
# Add holiday events to calendar
for child in FilePath(self.holidays_dir).children():
if os.path.splitext(child.basename())[1] != ".ics":
continue
request = SimpleStoreRequest(
self,
"PUT",
joinURL(calendar_uri, child.basename()),
headers=Headers({
"content-type":
MimeType.fromString("text/calendar")
}),
authPrincipal=self.authPrincipal)
request.stream = MemoryStream(child.getContent())
yield self.send(request)
request = SimpleStoreRequest(self,
"REPORT",
calendar_uri,
authPrincipal=self.authPrincipal)
request.stream = MemoryStream(query.toxml())
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.MULTI_STATUS:
self.fail("REPORT failed: %s" % (response.code, ))
returnValue((yield
davXMLFromStream(response.stream).addCallback(got_xml)))
def do_test(response):
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("MKCALENDAR failed: %s" % (response.code,))
resource = (yield request.locateResource(uri))
if not resource.isCalendarCollection():
self.fail("MKCALENDAR made non-calendar collection")
for qname, value in (
(davxml.DisplayName.qname(), "Lisa's Events"),
(caldavxml.CalendarDescription.qname(), "Calendar restricted to events."),
):
stored = yield resource.readProperty(qname, None)
stored = str(stored)
if stored != value:
self.fail("MKCALENDAR failed to set property %s: %s != %s"
% (qname, stored, value))
supported_components = yield resource.readProperty(caldavxml.SupportedCalendarComponentSet, None)
supported_components = supported_components.children
if len(supported_components) != 1:
self.fail("MKCALENDAR failed to set property %s: len(%s) != 1"
% (caldavxml.SupportedCalendarComponentSet.qname(), supported_components))
if supported_components[0] != caldavxml.CalendarComponent(name="VEVENT"):
self.fail("MKCALENDAR failed to set property %s: %s != %s"
% (caldavxml.SupportedCalendarComponentSet.qname(),
supported_components[0].toxml(), caldavxml.CalendarComponent(name="VEVENT").toxml()))
tz = (yield resource.readProperty(caldavxml.CalendarTimeZone, None))
tz = tz.calendar()
self.failUnless(tz.resourceType() == "VTIMEZONE")
self.failUnless(tuple(tz.subcomponents())[0].propertyValue("TZID") == "US-Eastern")
def do_test(response):
response = IResponse(response)
allow = response.headers.getHeader("allow")
if not allow:
self.fail("no Allow header: %s" % (response.headers, ))
self.assertIn("ACL", allow, "no ACL support")
def do_test(response):
response = IResponse(response)
if response.code != responsecode.FORBIDDEN:
self.fail(
"Incorrect response to MKCALENDAR on existing resource: %s"
% (response.code, ))
def do_test(response):
response = IResponse(response)
if response.code != responsecode.BAD_REQUEST:
self.fail(
"Unexpected response code for REPORT with no body: %s" %
(response.code, ))
def checkResult(response):
response = IResponse(response)
if response.code != responsecode.CONFLICT:
self.fail(
"Incorrect response code for PUT with no parent (%s != %s)"
% (response.code, responsecode.CONFLICT))
def checkResult(response, code=code):
response = IResponse(response)
if response.code != code:
self.fail(
"Incorrect response code for PUT (%s != %s)" %
(response.code, code))
def check_result(response, path):
response = IResponse(response)
if response.code != responsecode.NO_CONTENT:
self.fail("DELETE response %s != %s" % (response.code, responsecode.NO_CONTENT))
if os.path.exists(path):
self.fail("DELETE did not remove path %s" % (path,))
def checkResult(response):
response = IResponse(response)
if response.code != responsecode.INSUFFICIENT_STORAGE_SPACE:
self.fail("Incorrect response code for PUT (%s != %s)"
% (response.code, responsecode.INSUFFICIENT_STORAGE_SPACE))
return self.checkQuota(0)
def doTest(response):
response = IResponse(response)
dav = response.headers.getHeader("dav")
if not dav: self.fail("no DAV header: %s" % (response.headers, ))
self.assertIn(level, dav, "no DAV level %s header" % (level, ))
return response
def do_test(response):
response = IResponse(response)
dav = response.headers.getHeader("dav")
if not dav:
self.fail("no DAV header: %s" % (response.headers, ))
self.assertIn("1", dav, "no DAV level 1 header")
self.assertNotIn("addressbook", dav, "DAV addressbook header")
def checkDELETEResult(response):
response = IResponse(response)
if response.code != responsecode.NO_CONTENT:
self.fail("Incorrect response code for PUT (%s != %s)"
% (response.code, responsecode.NO_CONTENT))
return self.checkQuota(0)
def checkResult(response):
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("Incorrect response code for PUT (%s != %s)"
% (response.code, responsecode.CREATED))
return self.checkQuota(100)
def check_result(response):
response = IResponse(response)
if response.code != responsecode.MULTI_STATUS:
self.fail("Incorrect response code for PROPPATCH (%s != %s)" %
(response.code, responsecode.MULTI_STATUS))
return davXMLFromStream(response.stream).addCallback(check_xml)
def test_PROPFIND(self):
self.actualRoot.useSacls = True
body = """<?xml version="1.0" encoding="utf-8" ?>
<D:propfind xmlns:D="DAV:">
<D:prop>
<D:getetag/>
<D:displayname/>
</D:prop>
</D:propfind>
"""
principal = yield self.actualRoot.findPrincipalForAuthID("dreid")
request = SimpleStoreRequest(
self,
"PROPFIND",
"/principals/users/dreid/",
headers=http_headers.Headers({
'Depth': '1',
}),
authPrincipal=principal,
content=body
)
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.MULTI_STATUS:
self.fail("Incorrect response for PROPFIND /principals/: %s" % (response.code,))
request = SimpleStoreRequest(
self,
"PROPFIND",
"/principals/users/dreid/",
headers=http_headers.Headers({
'Depth': '1',
}),
authPrincipal=principal,
content=body
)
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.MULTI_STATUS:
self.fail("Incorrect response for PROPFIND /principals/: %s" % (response.code,))
self.assertEqual(self.actualRoot.responseCache.cacheHitCount, 1)
def check_result(response):
response = IResponse(response)
if response.code != responsecode.UNSUPPORTED_MEDIA_TYPE:
self.fail("MKCOL response %s != %s" %
(response.code, responsecode.UNSUPPORTED_MEDIA_TYPE))
if os.path.isdir(path):
self.fail("MKCOL incorrectly created directory %s" % (path, ))
def check_result(response):
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("MKCOL response %s != %s" %
(response.code, responsecode.CREATED))
if not os.path.isdir(path):
self.fail("MKCOL did not create directory %s" % (path, ))
def do_test(response):
response = IResponse(response)
dav = response.headers.getHeader("dav")
if not dav:
self.fail("no DAV header: %s" % (response.headers, ))
self.assertIn("1", dav, "no DAV level 1 header")
self.assertNotIn("calendar-access", dav,
"DAV calendar-access header")
def propfind_cb(response):
response = IResponse(response)
if response.code != responsecode.MULTI_STATUS:
self.fail("Incorrect response to PROPFIND: %s" %
(response.code, ))
def got_xml(doc):
if not isinstance(doc.root_element, davxml.MultiStatus):
self.fail(
"PROPFIND response XML root element is not multistatus: %r"
% (doc.root_element, ))
response = doc.root_element.childOfType(davxml.Response)
href = response.childOfType(davxml.HRef)
self.failUnless(str(href) == calendar_uri)
container = response.childOfType(
davxml.PropertyStatus).childOfType(
davxml.PropertyContainer)
#
# Check CalDAV:supported-calendar-component-set
#
supported_components = container.childOfType(
caldavxml.SupportedCalendarComponentSet)
if supported_components:
self.fail(
"CalDAV:supported-calendar-component-set element was returned; but should be hidden."
)
#
# Check CalDAV:supported-calendar-data
#
supported_calendar = container.childOfType(
caldavxml.SupportedCalendarData)
if supported_calendar:
self.fail(
"CalDAV:supported-calendar-data elementwas returned; but should be hidden."
)
#
# Check DAV:supported-report-set
#
supported_reports = container.childOfType(
davxml.SupportedReportSet)
if supported_reports:
self.fail(
"DAV:supported-report-set element was returned; but should be hidden.."
)
return davXMLFromStream(response.stream).addCallback(got_xml)
def do_test(response):
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("Incorrect response to successful MKCALENDAR: %s" %
(response.code, ))
resource = (yield request.locateResource(uri))
if not resource:
self.fail("MKCALENDAR made no calendar")
if not resource.isCalendarCollection():
self.fail("MKCALENDAR made non-calendar collection")
def free_busy_query(self, calendar_uri, query, got_calendar):
request = SimpleRequest(self.site, "MKCALENDAR", calendar_uri)
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("MKCALENDAR failed: %s" % (response.code, ))
yield addEventsDir(self, FilePath(self.holidays_dir), calendar_uri)
request = SimpleRequest(self.site, "REPORT", calendar_uri)
request.stream = MemoryStream(query.toxml())
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.OK:
self.fail("REPORT failed: %s" % (response.code, ))
result = yield Component.fromIStream(
response.stream).addCallback(got_calendar)
returnValue(result)
def check_result(response):
response = IResponse(response)
if response.code != responsecode.MULTI_STATUS:
self.fail("Incorrect response code for PROPFIND (%s != %s)"
% (response.code, responsecode.MULTI_STATUS))
content_type = response.headers.getHeader("content-type")
if content_type not in (http_headers.MimeType("text", "xml"),
http_headers.MimeType("application", "xml")):
self.fail("Incorrect content-type for PROPFIND response (%r not in %r)"
% (content_type, (http_headers.MimeType("text", "xml"),
http_headers.MimeType("application", "xml"))))
return davXMLFromStream(response.stream).addCallback(check_xml)
def do_test(response):
response = IResponse(response)
dav = response.headers.getHeader("dav")
if not dav:
self.fail("no DAV header: %s" % (response.headers, ))
self.assertIn("1", dav, "no DAV level 1 header")
self.assertIn("access-control", dav,
"no DAV access-control header")
self.assertIn("calendar-access", dav,
"no DAV calendar-access header")
self.assertIn("calendar-auto-schedule", dav,
"no DAV calendar-auto-schedule header")
self.assertIn("calendar-availability", dav,
"no DAV calendar-availability header")
def next(response):
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("MKCALENDAR failed: %s" % (response.code,))
def do_test(response):
response = IResponse(response)
if response.code != responsecode.FORBIDDEN:
self.fail("Incorrect response to nested MKCALENDAR: %s" % (response.code,))
nested_uri = os.path.join(first_uri, "nested")
request = SimpleStoreRequest(self, "MKCALENDAR", nested_uri, authPrincipal=self.authPrincipal)
yield self.send(request, do_test)
def calendar_query(self, query, got_xml):
principal = yield self.actualRoot.findPrincipalForAuthID("wsanchez")
request = SimpleStoreRequest(self,
"REPORT",
"/calendars/users/wsanchez/calendar/",
authPrincipal=principal)
request.stream = MemoryStream(query.toxml())
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.MULTI_STATUS:
self.fail("REPORT failed: %s" % (response.code, ))
returnValue((yield
davXMLFromStream(response.stream).addCallback(got_xml)))
def addressbook_query(self, addressbook_uri, query, got_xml):
''' FIXME: clear address book, possibly by removing
mkcol = """<?xml version="1.0" encoding="utf-8" ?>
<D:mkcol xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:carddav">
<D:set>
<D:prop>
<D:resourcetype><D:collection/><C:addressbook/></D:resourcetype>
</D:prop>
</D:set>
</D:mkcol>
"""
response = yield self.send(SimpleStoreRequest(self, "MKCOL", addressbook_uri, content=mkcol, authid="wsanchez"))
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("MKCOL failed: %s" % (response.code,))
'''
principal = yield self.actualRoot.findPrincipalForAuthID("wsanchez")
# Add vCards to addressbook
for child in FilePath(self.vcards_dir).children():
if os.path.splitext(child.basename())[1] != ".vcf":
continue
request = SimpleStoreRequest(self,
"PUT",
joinURL(addressbook_uri,
child.basename()),
authPrincipal=principal)
request.stream = MemoryStream(child.getContent())
yield self.send(request)
request = SimpleStoreRequest(self,
"REPORT",
addressbook_uri,
authPrincipal=principal)
request.stream = MemoryStream(query.toxml())
response = yield self.send(request)
response = IResponse(response)
if response.code != responsecode.MULTI_STATUS:
self.fail("REPORT failed: %s" % (response.code, ))
returnValue((yield
davXMLFromStream(response.stream).addCallback(got_xml)))
def checkPUTResult(response):
response = IResponse(response)
if response.code != responsecode.CREATED:
self.fail("Incorrect response code for PUT (%s != %s)"
% (response.code, responsecode.CREATED))
def doBadAdjustment(_ignore):
def checkAdjustmentResult(_ignore):
return self.checkQuota(100)
d = self.site.resource.quotaSizeAdjust(None, -200)
d.addCallback(checkAdjustmentResult)
return d
d = self.checkQuota(100)
d.addCallback(doBadAdjustment)
return d