def __init__(self): SchemeRegistryResolver.__init__(self)
def __init__(self):
SchemeRegistryResolver.__init__(self)
def Test(tester):
tester.startGroup('UriDict')
tester.startGroup('file:/// and file://localhost/ equivalence')
tester.startTest('equivalent key in UriDict')
uris = Uri.UriDict()
uris['file:///path/to/resource'] = 0
tester.compare(True, 'file://localhost/path/to/resource' in uris,
'RFC 1738 localhost support failed')
tester.testDone()
tester.startTest('value of 2 equivalent keys')
uris = Uri.UriDict()
uris['file:///path/to/resource'] = 1
uris['file://localhost/path/to/resource'] = 2
tester.compare(2, uris['file:///path/to/resource'],
'RFC 1738 localhost support failed')
tester.testDone()
tester.groupDone()
tester.startGroup('case equivalence')
for uri, expected, junk in caseNormalizationTests:
tester.startTest('%s and %s equivalence' % (uri, expected))
uris[uri] = 1
uris[expected] = 2
tester.compare(2, uris[uri])
tester.testDone()
tester.groupDone()
tester.startGroup('percent-encoding equivalence')
for uri, expected in pctEncNormalizationTests:
tester.startTest('%s and %s equivalence' % (uri, expected))
uris[uri] = 1
uris[expected] = 2
tester.compare(2, uris[uri])
tester.testDone()
tester.groupDone()
tester.groupDone()
tester.startGroup("PercentEncode and PercentDecode")
for unencoded, encoded in percentEncodeTests:
if len(unencoded) > 10:
test_title = unencoded[:11] + '...'
else:
test_title = unencoded
tester.startTest(repr(test_title))
tester.compare(encoded, Uri.PercentEncode(unencoded))
tester.compare(unencoded, Uri.PercentDecode(encoded))
tester.testDone()
# non-BMP tests:
# a couple of random chars from U+10000 to U+10FFFD.
#
# This string will be length 2 or 4 depending on how Python
# was built. Either way, it should result in the same percent-
# encoded sequence, which should decode back to the original
# representation.
unencoded = u'\U00010000\U0010FFFD'
encoded = u'%F0%90%80%80%F4%8F%BF%BD'
tester.startTest("u'\U00010000\U0010FFFD'")
tester.compare(encoded, Uri.PercentEncode(unencoded))
tester.compare(unencoded, Uri.PercentDecode(encoded))
tester.testDone()
#
# This string will be length 4, regardless of how Python was
# built. However, if Python was built with wide (UCS-4) chars,
# PercentDecode will generate an optimal string (length: 2).
unencoded_in = u'\ud800\udc00\udbff\udffd'
encoded = u'%F0%90%80%80%F4%8F%BF%BD'
unencoded_out = u'\U00010000\U0010FFFD'
tester.startTest("u'\ud800\udc00\udbff\udffd'")
tester.compare(encoded, Uri.PercentEncode(unencoded_in))
tester.compare(unencoded_out, Uri.PercentDecode(encoded))
tester.testDone()
# test a few iso-8859-n variations just to make sure
# iso-8859-1 isn't special
unencoded = ''.join(map(chr, range(256)))
encoded = '%00%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F' \
'%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F' \
'%20%21%22%23%24%25%26%27%28%29%2A%2B%2C-.%2F' \
'0123456789%3A%3B%3C%3D%3E%3F%40' \
'ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60' \
'abcdefghijklmnopqrstuvwxyz%7B%7C%7D~' \
'%7F%80%81%82%83%84%85%86%87%88%89%8A%8B%8C%8D%8E%8F' \
'%90%91%92%93%94%95%96%97%98%99%9A%9B%9C%9D%9E%9F' \
'%A0%A1%A2%A3%A4%A5%A6%A7%A8%A9%AA%AB%AC%AD%AE%AF' \
'%B0%B1%B2%B3%B4%B5%B6%B7%B8%B9%BA%BB%BC%BD%BE%BF' \
'%C0%C1%C2%C3%C4%C5%C6%C7%C8%C9%CA%CB%CC%CD%CE%CF' \
'%D0%D1%D2%D3%D4%D5%D6%D7%D8%D9%DA%DB%DC%DD%DE%DF' \
'%E0%E1%E2%E3%E4%E5%E6%E7%E8%E9%EA%EB%EC%ED%EE%EF' \
'%F0%F1%F2%F3%F4%F5%F6%F7%F8%F9%FA%FB%FC%FD%FE%FF'
for part in (1, 2, 3, 15):
enc_name = 'iso-8859-%d' % part
tester.startTest(enc_name)
try:
codecs.lookup(enc_name)
except LookupError:
tester.warning('Not supported on this platform')
tester.testDone()
continue
tester.compare(encoded, Uri.PercentEncode(unencoded,
encoding=enc_name))
tester.compare(unencoded, Uri.PercentDecode(encoded,
encoding=enc_name))
tester.testDone()
# utf-16be: why not?
unencoded = u'a test string...\x00\xe9...\x20\x22...\xd8\x00\xdc\x00'
encoded = u'a%20test%20string...\u00e9...%20%22...%D8%00%DC%00'
tester.groupDone()
tester.startGroup("PublicIdToUrn")
for publicid, urn in publicIdTests:
tester.startTest(publicid)
tester.compare(urn, Uri.PublicIdToUrn(publicid))
tester.testDone()
tester.groupDone()
tester.startGroup("UrnToPublicId")
for publicid, urn in publicIdTests:
tester.startTest(urn)
tester.compare(publicid, Uri.UrnToPublicId(urn))
tester.testDone()
tester.groupDone()
tester.startGroup("URI reference syntax")
for testuri in good_URI_references:
tester.startTest("Good URI ref: %s" % repr(testuri))
tester.compare(1, Uri.MatchesUriRefSyntax(testuri),
"Mistakenly tests as invalid")
tester.testDone()
for testuri in bad_URI_references:
tester.startTest("Bad URI ref: %s" % repr(testuri))
tester.compare(0, Uri.MatchesUriRefSyntax(testuri),
"Mistakenly tests as valid")
tester.testDone()
tester.groupDone()
tester.startGroup('Absolutize')
for uriRef, baseUri, expectedUri in absolutize_test_cases:
tester.startTest('base=%r ref=%r' % (baseUri, uriRef))
res = Uri.Absolutize(uriRef, baseUri)
# in a couple cases, there's more than one correct result
if isinstance(expectedUri, tuple):
tester.compare(1, res in expectedUri, 'Invalid result')
else:
tester.compare(expectedUri, res, 'Invalid result')
tester.testDone()
tester.groupDone()
tester.startGroup('Relativize')
for targetUri, againstUri, relativeUri, subPathUri in relativize_test_cases:
tester.startTest('target=%r against=%r (subPathOnly=False)' %
(targetUri, againstUri))
res = Uri.Relativize(targetUri, againstUri)
tester.compare(relativeUri, res, 'Invalid result')
tester.testDone()
if res is not None:
tester.startTest(
'target=%r against=%r (subPathOnly=False, Absolutize)' %
(targetUri, againstUri))
res = Uri.Absolutize(res, againstUri)
tester.compare(res, targetUri, 'Invalid result')
tester.testDone()
tester.startTest('target=%r against=%r (subPathOnly=True)' %
(targetUri, againstUri))
res = Uri.Relativize(targetUri, againstUri, True)
tester.compare(subPathUri, res, 'Invalid result')
tester.testDone()
if res is not None:
tester.startTest(
'target=%r against=%r (subPathOnly=True, Absolutize)' %
(targetUri, againstUri))
res = Uri.Absolutize(res, againstUri)
tester.compare(res, targetUri, 'Invalid result')
tester.testDone()
tester.groupDone()
tester.startGroup('BaseJoin')
for base, relative, expectedUri in basejoin_test_cases:
tester.startTest('base=%r rel=%r' % (base, relative))
res = Uri.BaseJoin(base, relative)
tester.compare(expectedUri, res, 'Invalid result')
tester.testDone()
tester.groupDone()
tester.startGroup('UriToOsPath')
for osname in ('posix', 'nt'):
tester.startGroup(osname)
for subgroupname in ('absolute', 'relative'):
tester.startGroup(subgroupname)
for uri, nt_path, posix_path in fileUris:
if subgroupname == 'relative':
if uri[:5] == 'file:':
uri = uri[5:]
else:
break
if isinstance(uri, unicode):
testname = repr(uri)
else:
testname = uri
tester.startTest(testname)
if osname == 'nt':
path = nt_path
elif osname == 'posix':
path = posix_path
else:
break
if path is None:
tester.testException(Uri.UriToOsPath, (uri, ),
Uri.UriException,
kwargs={
'attemptAbsolute': False,
'osname': osname
})
else:
tester.compare(
path,
Uri.UriToOsPath(uri,
attemptAbsolute=False,
osname=osname))
tester.testDone()
tester.groupDone()
tester.groupDone()
tester.groupDone()
tester.startGroup('OsPathToUri')
for osname in ('posix', 'nt'):
tester.startGroup(osname)
for path, nt_uri, posix_uri in filePaths:
if isinstance(path, unicode):
testname = repr(path)
else:
testname = path
tester.startTest(testname)
if osname == 'nt':
uri = nt_uri
elif osname == 'posix':
uri = posix_uri
else:
break
if uri is None:
tester.testException(Uri.OsPathToUri, (path, ),
Uri.UriException,
kwargs={
'attemptAbsolute': False,
'osname': osname
})
else:
tester.compare(
uri,
Uri.OsPathToUri(path, attemptAbsolute=False,
osname=osname))
tester.testDone()
tester.groupDone()
tester.groupDone()
tester.startGroup('NormalizeCase')
for uri, expected0, expected1 in caseNormalizationTests:
testname = uri
uri = Uri.SplitUriRef(uri)
tester.startTest(testname)
tester.compare(expected0, Uri.UnsplitUriRef(Uri.NormalizeCase(uri)))
tester.testDone()
tester.startTest(testname + ' (host too)')
tester.compare(expected1,
Uri.UnsplitUriRef(Uri.NormalizeCase(uri, doHost=1)))
tester.testDone()
tester.groupDone()
tester.startGroup('NormalizePercentEncoding')
for uri, expected in pctEncNormalizationTests:
testname = uri
tester.startTest(testname)
tester.compare(expected, Uri.NormalizePercentEncoding(uri))
tester.testDone()
tester.groupDone()
tester.startGroup('NormalizePathSegments')
for path, expected in pathSegmentNormalizationTests:
testname = path
tester.startTest(testname)
tester.compare(expected, Uri.NormalizePathSegments(path))
tester.testDone()
tester.groupDone()
tester.startGroup('NormalizePathSegmentsInUri')
for path, expectedpath in pathSegmentNormalizationTests:
# for non-hierarchical scheme, no change expected in every case
uri = 'urn:bogus:%s?a=1&b=2#frag' % path
expected = 'urn:bogus:%s?a=1&b=2#frag' % path
testname = uri
tester.startTest(testname)
tester.compare(expected, Uri.NormalizePathSegmentsInUri(uri))
tester.testDone()
for path, expectedpath in pathSegmentNormalizationTests:
if path[:1] == '/':
# hierarchical scheme
uri = 'file://*****:*****@host%s?a=1&b=2#frag' % path
expected = 'file://*****:*****@host%s?a=1&b=2#frag' % expectedpath
testname = uri
tester.startTest(testname)
tester.compare(expected, Uri.NormalizePathSegmentsInUri(uri))
tester.testDone()
tester.groupDone()
tester.startGroup("MakeUrllibSafe")
tests = makeUrllibSafeTests
if os.name == 'nt':
tests += winMakeUrllibSafeTests
for uri, expected in makeUrllibSafeTests:
if isinstance(uri, unicode):
test_title = repr(uri)
else:
test_title = uri
tester.startTest(test_title)
res = Uri.MakeUrllibSafe(uri)
tester.compare(expected, res)
tester.testDone()
tester.groupDone()
tester.startGroup("Basic Uri Resolver")
data = [
('http://foo.com/root/', 'path', 'http://foo.com/root/path'),
('http://foo.com/root', 'path', 'http://foo.com/path'),
]
for base, uri, exp in data:
tester.startTest("normalize: %s %s" % (base, uri))
res = Uri.BASIC_RESOLVER.normalize(uri, base)
tester.compare(exp, res)
tester.testDone()
base = 'foo:foo.com'
uri = 'path'
tester.startTest("normalize: %s %s" % (base, uri))
tester.testException(Uri.BASIC_RESOLVER.normalize, (uri, base),
Uri.UriException)
tester.testDone()
tester.startTest('resolve')
base = os.getcwd()
if base[-1] != os.sep:
base += os.sep
stream = Uri.BASIC_RESOLVER.resolve('test.py', Uri.OsPathToUri(base))
tester.compare(TEST_DOT_PY_BANGPATH, string.rstrip(stream.readline()))
stream.close()
tester.testDone()
tester.startTest('generate')
uuid = Uri.BASIC_RESOLVER.generate()
tester.compare('urn:uuid:', uuid[:9])
tester.testDone()
tester.groupDone()
tester.startGroup("SchemeRegistryResolver")
def evalSchemeHandler(uri, base=None):
if base: uri = base + uri
uri = uri[5:]
return str(eval(uri))
def shiftSchemeHandler(uri, base=None):
if base: uri = base + uri
uri = uri[6:]
return ''.join([chr(ord(c) + 1) for c in uri])
resolver = SchemeRegistryResolver({
'eval': evalSchemeHandler,
'shift': shiftSchemeHandler,
})
scheme_cases = [
(None, 'eval:150-50', '100'),
(None, 'shift:abcde', 'bcdef'),
('eval:150-', '50', '100'),
('shift:ab', 'cde', 'bcdef'),
]
for base, relative, expected in scheme_cases:
tester.startTest("URI: base=%s uri=%s" % (base, relative))
res = resolver.resolve(relative, base)
tester.compare(expected, res)
tester.testDone()
resolver.handlers[None] = shiftSchemeHandler
del resolver.handlers['shift']
for base, relative, expected in scheme_cases:
tester.startTest("URI: base=%s uri=%s" % (base, relative))
res = resolver.resolve(relative, base)
tester.compare(expected, res)
tester.testDone()
tester.groupDone()
return
def Test(tester):
tester.startGroup('UriDict')
tester.startGroup('file:/// and file://localhost/ equivalence')
tester.startTest('equivalent key in UriDict')
uris = Uri.UriDict()
uris['file:///path/to/resource'] = 0
tester.compare(True, 'file://localhost/path/to/resource' in uris, 'RFC 1738 localhost support failed')
tester.testDone()
tester.startTest('value of 2 equivalent keys')
uris = Uri.UriDict()
uris['file:///path/to/resource'] = 1
uris['file://localhost/path/to/resource'] = 2
tester.compare(2, uris['file:///path/to/resource'], 'RFC 1738 localhost support failed')
tester.testDone()
tester.groupDone()
tester.startGroup('case equivalence')
for uri, expected, junk in caseNormalizationTests:
tester.startTest('%s and %s equivalence' % (uri, expected))
uris[uri] = 1
uris[expected] = 2
tester.compare(2, uris[uri])
tester.testDone()
tester.groupDone()
tester.startGroup('percent-encoding equivalence')
for uri, expected in pctEncNormalizationTests:
tester.startTest('%s and %s equivalence' % (uri, expected))
uris[uri] = 1
uris[expected] = 2
tester.compare(2, uris[uri])
tester.testDone()
tester.groupDone()
tester.groupDone()
tester.startGroup("PercentEncode and PercentDecode")
for unencoded, encoded in percentEncodeTests:
if len(unencoded) > 10:
test_title = unencoded[:11] + '...'
else:
test_title = unencoded
tester.startTest(repr(test_title))
tester.compare(encoded, Uri.PercentEncode(unencoded))
tester.compare(unencoded, Uri.PercentDecode(encoded))
tester.testDone()
# non-BMP tests:
# a couple of random chars from U+10000 to U+10FFFD.
#
# This string will be length 2 or 4 depending on how Python
# was built. Either way, it should result in the same percent-
# encoded sequence, which should decode back to the original
# representation.
unencoded = u'\U00010000\U0010FFFD'
encoded = u'%F0%90%80%80%F4%8F%BF%BD'
tester.startTest("u'\U00010000\U0010FFFD'")
tester.compare(encoded, Uri.PercentEncode(unencoded))
tester.compare(unencoded, Uri.PercentDecode(encoded))
tester.testDone()
#
# This string will be length 4, regardless of how Python was
# built. However, if Python was built with wide (UCS-4) chars,
# PercentDecode will generate an optimal string (length: 2).
unencoded_in = u'\ud800\udc00\udbff\udffd'
encoded = u'%F0%90%80%80%F4%8F%BF%BD'
unencoded_out = u'\U00010000\U0010FFFD'
tester.startTest("u'\ud800\udc00\udbff\udffd'")
tester.compare(encoded, Uri.PercentEncode(unencoded_in))
tester.compare(unencoded_out, Uri.PercentDecode(encoded))
tester.testDone()
# test a few iso-8859-n variations just to make sure
# iso-8859-1 isn't special
unencoded = ''.join(map(chr, range(256)))
encoded = '%00%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F' \
'%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F' \
'%20%21%22%23%24%25%26%27%28%29%2A%2B%2C-.%2F' \
'0123456789%3A%3B%3C%3D%3E%3F%40' \
'ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60' \
'abcdefghijklmnopqrstuvwxyz%7B%7C%7D~' \
'%7F%80%81%82%83%84%85%86%87%88%89%8A%8B%8C%8D%8E%8F' \
'%90%91%92%93%94%95%96%97%98%99%9A%9B%9C%9D%9E%9F' \
'%A0%A1%A2%A3%A4%A5%A6%A7%A8%A9%AA%AB%AC%AD%AE%AF' \
'%B0%B1%B2%B3%B4%B5%B6%B7%B8%B9%BA%BB%BC%BD%BE%BF' \
'%C0%C1%C2%C3%C4%C5%C6%C7%C8%C9%CA%CB%CC%CD%CE%CF' \
'%D0%D1%D2%D3%D4%D5%D6%D7%D8%D9%DA%DB%DC%DD%DE%DF' \
'%E0%E1%E2%E3%E4%E5%E6%E7%E8%E9%EA%EB%EC%ED%EE%EF' \
'%F0%F1%F2%F3%F4%F5%F6%F7%F8%F9%FA%FB%FC%FD%FE%FF'
for part in (1,2,3,15):
enc_name = 'iso-8859-%d' % part
tester.startTest(enc_name)
try:
codecs.lookup(enc_name)
except LookupError:
tester.warning('Not supported on this platform')
tester.testDone()
continue
tester.compare(encoded, Uri.PercentEncode(unencoded, encoding=enc_name))
tester.compare(unencoded, Uri.PercentDecode(encoded, encoding=enc_name))
tester.testDone()
# utf-16be: why not?
unencoded = u'a test string...\x00\xe9...\x20\x22...\xd8\x00\xdc\x00'
encoded = u'a%20test%20string...\u00e9...%20%22...%D8%00%DC%00'
tester.groupDone()
tester.startGroup("PublicIdToUrn")
for publicid, urn in publicIdTests:
tester.startTest(publicid)
tester.compare(urn, Uri.PublicIdToUrn(publicid))
tester.testDone()
tester.groupDone()
tester.startGroup("UrnToPublicId")
for publicid, urn in publicIdTests:
tester.startTest(urn)
tester.compare(publicid, Uri.UrnToPublicId(urn))
tester.testDone()
tester.groupDone()
tester.startGroup("URI reference syntax")
for testuri in good_URI_references:
tester.startTest("Good URI ref: %s" % repr(testuri))
tester.compare(1, Uri.MatchesUriRefSyntax(testuri), "Mistakenly tests as invalid")
tester.testDone()
for testuri in bad_URI_references:
tester.startTest("Bad URI ref: %s" % repr(testuri))
tester.compare(0, Uri.MatchesUriRefSyntax(testuri), "Mistakenly tests as valid")
tester.testDone()
tester.groupDone()
tester.startGroup('Absolutize')
for uriRef, baseUri, expectedUri in absolutize_test_cases:
tester.startTest('base=%r ref=%r' % (baseUri, uriRef))
res = Uri.Absolutize(uriRef, baseUri)
# in a couple cases, there's more than one correct result
if isinstance(expectedUri, tuple):
tester.compare(1, res in expectedUri, 'Invalid result')
else:
tester.compare(expectedUri, res, 'Invalid result')
tester.testDone()
tester.groupDone()
tester.startGroup('Relativize')
for targetUri, againstUri, relativeUri, subPathUri in relativize_test_cases:
tester.startTest('target=%r against=%r (subPathOnly=False)' %
(targetUri, againstUri))
res = Uri.Relativize(targetUri, againstUri)
tester.compare(relativeUri, res, 'Invalid result')
tester.testDone()
if res is not None:
tester.startTest(
'target=%r against=%r (subPathOnly=False, Absolutize)' %
(targetUri, againstUri))
res = Uri.Absolutize(res, againstUri)
tester.compare(res, targetUri, 'Invalid result')
tester.testDone()
tester.startTest('target=%r against=%r (subPathOnly=True)' %
(targetUri, againstUri))
res = Uri.Relativize(targetUri, againstUri, True)
tester.compare(subPathUri, res, 'Invalid result')
tester.testDone()
if res is not None:
tester.startTest(
'target=%r against=%r (subPathOnly=True, Absolutize)' %
(targetUri, againstUri))
res = Uri.Absolutize(res, againstUri)
tester.compare(res, targetUri, 'Invalid result')
tester.testDone()
tester.groupDone()
tester.startGroup('BaseJoin')
for base, relative, expectedUri in basejoin_test_cases:
tester.startTest('base=%r rel=%r' % (base,relative))
res = Uri.BaseJoin(base, relative)
tester.compare(expectedUri, res, 'Invalid result')
tester.testDone()
tester.groupDone()
tester.startGroup('UriToOsPath')
for osname in ('posix', 'nt'):
tester.startGroup(osname)
for subgroupname in ('absolute', 'relative'):
tester.startGroup(subgroupname)
for uri, nt_path, posix_path in fileUris:
if subgroupname == 'relative':
if uri[:5] == 'file:':
uri = uri[5:]
else:
break
if isinstance(uri, unicode):
testname = repr(uri)
else:
testname = uri
tester.startTest(testname)
if osname == 'nt':
path = nt_path
elif osname == 'posix':
path = posix_path
else:
break
if path is None:
tester.testException(Uri.UriToOsPath, (uri,),
Uri.UriException, kwargs={'attemptAbsolute':False, 'osname': osname})
else:
tester.compare(path, Uri.UriToOsPath(uri, attemptAbsolute=False, osname=osname))
tester.testDone()
tester.groupDone()
tester.groupDone()
tester.groupDone()
tester.startGroup('OsPathToUri')
for osname in ('posix', 'nt'):
tester.startGroup(osname)
for path, nt_uri, posix_uri in filePaths:
if isinstance(path, unicode):
testname = repr(path)
else:
testname = path
tester.startTest(testname)
if osname == 'nt':
uri = nt_uri
elif osname == 'posix':
uri = posix_uri
else:
break
if uri is None:
tester.testException(Uri.OsPathToUri, (path,),
Uri.UriException, kwargs={'attemptAbsolute': False, 'osname': osname})
else:
tester.compare(uri, Uri.OsPathToUri(path, attemptAbsolute=False, osname=osname))
tester.testDone()
tester.groupDone()
tester.groupDone()
tester.startGroup('NormalizeCase')
for uri, expected0, expected1 in caseNormalizationTests:
testname = uri
uri = Uri.SplitUriRef(uri)
tester.startTest(testname)
tester.compare(expected0, Uri.UnsplitUriRef(Uri.NormalizeCase(uri)))
tester.testDone()
tester.startTest(testname + ' (host too)')
tester.compare(expected1, Uri.UnsplitUriRef(Uri.NormalizeCase(uri, doHost=1)))
tester.testDone()
tester.groupDone()
tester.startGroup('NormalizePercentEncoding')
for uri, expected in pctEncNormalizationTests:
testname = uri
tester.startTest(testname)
tester.compare(expected, Uri.NormalizePercentEncoding(uri))
tester.testDone()
tester.groupDone()
tester.startGroup('NormalizePathSegments')
for path, expected in pathSegmentNormalizationTests:
testname = path
tester.startTest(testname)
tester.compare(expected, Uri.NormalizePathSegments(path))
tester.testDone()
tester.groupDone()
tester.startGroup('NormalizePathSegmentsInUri')
for path, expectedpath in pathSegmentNormalizationTests:
# for non-hierarchical scheme, no change expected in every case
uri = 'urn:bogus:%s?a=1&b=2#frag' % path
expected = 'urn:bogus:%s?a=1&b=2#frag' % path
testname = uri
tester.startTest(testname)
tester.compare(expected, Uri.NormalizePathSegmentsInUri(uri))
tester.testDone()
for path, expectedpath in pathSegmentNormalizationTests:
if path[:1] == '/':
# hierarchical scheme
uri = 'file://*****:*****@host%s?a=1&b=2#frag' % path
expected = 'file://*****:*****@host%s?a=1&b=2#frag' % expectedpath
testname = uri
tester.startTest(testname)
tester.compare(expected, Uri.NormalizePathSegmentsInUri(uri))
tester.testDone()
tester.groupDone()
tester.startGroup("MakeUrllibSafe")
tests = makeUrllibSafeTests
if os.name == 'nt':
tests += winMakeUrllibSafeTests
for uri, expected in makeUrllibSafeTests:
if isinstance(uri, unicode):
test_title = repr(uri)
else:
test_title = uri
tester.startTest(test_title)
res = Uri.MakeUrllibSafe(uri)
tester.compare(expected, res)
tester.testDone()
tester.groupDone()
tester.startGroup("Basic Uri Resolver")
data = [('http://foo.com/root/', 'path', 'http://foo.com/root/path'),
('http://foo.com/root', 'path', 'http://foo.com/path'),
]
for base,uri,exp in data:
tester.startTest("normalize: %s %s" % (base, uri))
res = Uri.BASIC_RESOLVER.normalize(uri, base)
tester.compare(exp, res)
tester.testDone()
base = 'foo:foo.com'
uri = 'path'
tester.startTest("normalize: %s %s" % (base, uri))
tester.testException(Uri.BASIC_RESOLVER.normalize, (uri, base), Uri.UriException)
tester.testDone()
tester.startTest('resolve')
base = os.getcwd()
if base[-1] != os.sep:
base += os.sep
stream = Uri.BASIC_RESOLVER.resolve('test.py', Uri.OsPathToUri(base))
tester.compare(TEST_DOT_PY_BANGPATH, string.rstrip(stream.readline()))
stream.close()
tester.testDone()
tester.startTest('generate')
uuid = Uri.BASIC_RESOLVER.generate()
tester.compare('urn:uuid:', uuid[:9])
tester.testDone()
tester.groupDone()
tester.startGroup("SchemeRegistryResolver")
def evalSchemeHandler(uri, base=None):
if base: uri = base+uri
uri = uri[5:]
return str(eval(uri))
def shiftSchemeHandler(uri, base=None):
if base: uri = base+uri
uri = uri[6:]
return ''.join([ chr(ord(c)+1) for c in uri])
resolver = SchemeRegistryResolver({'eval': evalSchemeHandler,
'shift': shiftSchemeHandler,
})
scheme_cases = [(None, 'eval:150-50', '100'),
(None, 'shift:abcde', 'bcdef'),
('eval:150-', '50', '100'),
('shift:ab', 'cde', 'bcdef'),
]
for base, relative, expected in scheme_cases:
tester.startTest("URI: base=%s uri=%s" % (base, relative))
res = resolver.resolve(relative, base)
tester.compare(expected, res)
tester.testDone()
resolver.handlers[None] = shiftSchemeHandler
del resolver.handlers['shift']
for base, relative, expected in scheme_cases:
tester.startTest("URI: base=%s uri=%s" % (base, relative))
res = resolver.resolve(relative, base)
tester.compare(expected, res)
tester.testDone()
tester.groupDone()
return