def test_fragment(self): u = uri.URI(SIMPLE_EXAMPLE) self.assertTrue(u.fragment is None, "no fragment") u = uri.URI('http://www.ics.uci.edu/pub/ietf/uri/#Related') self.assertTrue(u.scheme_specific_part == '//www.ics.uci.edu/pub/ietf/uri/', 'URI with fragment') self.assertTrue(u.fragment == 'Related', 'fragment')
def test_compare(self): u1 = uri.URI("x-HTTP://www.example.com/") u2 = uri.URI("x-http://www.example.com/") self.assertTrue( u1.match(u2) and u2.match(u1), "Equal URIs fail to match") self.assertTrue(u1 == u2, "Equal URIs compare equal") self.assertFalse(u1 != u2, "Equal URIs compare not equal") self.assertTrue(u1 <= u2, "Equal URIs sort less-equal") self.assertTrue(u1 >= u2, "Equal URIs sort greater-equal") self.assertFalse(u1 < u2, "Equal URIs sort less than") self.assertFalse(u1 > u2, "Equal URIs sort greater than") self.assertTrue(hash(u1) == hash(u2), "Equal URIs, equal hash") u2 = uri.URI('hello.xml') self.assertFalse( u1.match(u2) or u2.match(u1), "Mismatched URIs do match") u1 = uri.URI("x-HTTP://www.example.com/") u2 = uri.URI("x-http://www2.example.com/") self.assertFalse( u1.match(u2) or u2.match(u1), "Equal URIs fail to match") self.assertFalse(u1 == u2, "Unequal URIs compare equal") self.assertTrue(u1 != u2, "Unequal URIs compare not-equal") self.assertTrue(u1 <= u2, "Unequal URIs sort less-equal") self.assertFalse(u1 >= u2, "Unequal URIs sort greater-equal") self.assertTrue(u1 < u2, "Unequal URIs sort less than") self.assertFalse(u1 > u2, "Unequal URIs sort greater than") self.assertFalse(hash(u1) == hash(u2), "Unequal URIs, Unequal hash") # check comparison against strings u2 = "x-http://www3.example.com/" self.assertFalse(u1 == u2, "Unequal URIs compare equal") self.assertTrue(u1 != u2, "Unequal URIs compare not-equal") self.assertTrue(u1 <= u2, "Unequal URIs sort less-equal") self.assertFalse(u1 >= u2, "Unequal URIs sort greater-equal") self.assertTrue(u1 < u2, "Unequal URIs sort less than") self.assertFalse(u1 > u2, "Unequal URIs sort greater than")
def test_constructor(self): u = uri.URI(SIMPLE_EXAMPLE) self.assertTrue(isinstance(u, uri.URI)) self.assertTrue(str(u) == SIMPLE_EXAMPLE) self.assertTrue(is_unicode(u.octets), "octets must be a character string") if py2: self.assertTrue(to_text(u) == SIMPLE_EXAMPLE) try: u = uri.URI(LIST_EXAMPLE) # we don't support this type of thing any more # self.assertTrue(str(u)==SIMPLE_EXAMPLE,"Simple from list") except uri.URIException: pass u = uri.URI.from_octets(u8(b'\xe8\x8b\xb1\xe5\x9b\xbd.xml')) self.assertTrue( str(u) == '%E8%8B%B1%E5%9B%BD.xml', "Unicode example: %s" % str(u)) self.assertTrue(is_unicode(u.octets), "octets must be a character string") try: u = uri.URI.from_octets(u8(b'\xe8\x8b\xb1\xe5\x9b\xbd.xml'), strict=True) self.fail("strict mode requires %-encoding") except uri.URIException: pass # binary string must be US-ASCII clean try: u = uri.URI.from_octets(b'Caf\xe9') self.fail("binary string must be US-ASCII") except UnicodeDecodeError: pass # but URI-encoded is OK even if it is binary u = uri.URI.from_octets(b'Caf%E9') self.assertTrue(is_unicode(u.octets), "octets must be a character string")
def test_scheme(self): u = uri.URI(SIMPLE_EXAMPLE) self.assertTrue(u.is_absolute(), "Absolute test") self.assertTrue(u.scheme == 'http', "Scheme") self.assertTrue(u.scheme_specific_part == '//www.example.com/') u = uri.URI(RELATIVE_EXAMPLE) self.assertFalse(u.is_absolute(), "Relative test") self.assertTrue(u.scheme is None, "relative scheme") self.assertTrue(u.scheme_specific_part is None)
def test_relative_join_examples(self): keys = REL_EXAMPLES.keys() base1 = uri.URI(REL_BASE1) base2 = uri.URI(REL_BASE2) current = uri.URI(REL_CURRENT) relatives = {} for k in keys: u = uri.URI(k) if not u.octets: # don't test same document cases continue resolved, scheme, authority, abs_path, rel_path, query, \ fragment = REL_EXAMPLES[k] logging.info("Testing: %s [*] ( %s [*] %s ) = %s", str(base1), str(base2), k, resolved) # two-step resolution, first combines relative URLs, second # resolves to absolute resolution1 = u.resolve(base2, current) relatives[str(resolution1)] = relatives.get(str(resolution1), []) + [k] resolution2 = str(resolution1.resolve(base1, current)) self.assertTrue(scheme == u.scheme, "%s found scheme %s" % (k, u.scheme)) self.assertTrue(authority == u.authority, "%s found authority %s" % (k, u.authority)) self.assertTrue(abs_path == u.abs_path, "%s found abs_path %s" % (k, u.abs_path)) self.assertTrue(rel_path == u.rel_path, "%s found rel_path %s" % (k, u.rel_path)) self.assertTrue(query == u.query, "%s found query %s" % (k, u.query)) self.assertTrue(fragment == u.fragment, "%s found fragment %s" % (k, u.fragment)) self.assertTrue( resolved == resolution2, "%s [*] ( %s [*] %s ) = %s ; found %s" % (str(base1), str(base2), k, resolved, resolution2)) for r in relatives.keys(): logging.info("Testing: %s [/] %s = ( %s )", r, str(base2), string.join(relatives[r], ' | ')) u = uri.URI(r) # this check removes the 'current document' case if u.octets == 'current.doc': continue relative = str(u.relative(base2)) # now relative should be one of the relatives! no_match = True for k in relatives[r]: if k == relative: no_match = False break self.assertFalse( no_match, "%s [/] %s = ( %s ); found %s" % (r, str(base2), repr(relatives[r]), relative))
def test_compare(self): u1 = uri.URI(SIMPLE_EXAMPLE) u2 = uri.URI(SIMPLE_EXAMPLE) self.assertTrue( u1.match(u2) and u2.match(u1), "Equal URIs fail to match") u2 = uri.URI('hello.xml') self.assertFalse( u1.match(u2) or u2.match(u1), "Mismatched URIs do match") u1 = uri.URI("HTTP://www.example.com/") u2 = uri.URI("http://www.example.com/") self.assertTrue( u1.match(u2) and u2.match(u1), "Equal URIs fail to match")
def test_constructor(self): u = uri.URI(SIMPLE_EXAMPLE) self.assertTrue(isinstance(u, uri.URI)) self.assertTrue(str(u) == SIMPLE_EXAMPLE) try: u = uri.URI(LIST_EXAMPLE) # we don't support this type of thing any more # self.assertTrue(str(u)==SIMPLE_EXAMPLE,"Simple from list") except uri.URIException: pass u = uri.URI.from_octets(u'\u82f1\u56fd.xml') self.assertTrue( str(u) == '%E8%8B%B1%E5%9B%BD.xml', "Unicode example: %s" % str(u)) self.assertTrue(type(u.octets) is StringType, "octest must be string")
def test_canonicalize(self): u = uri.URI('X-Pyslet:50%2f50') u2 = u.canonicalize() self.assertTrue(str(u2) == 'x-pyslet:50%2f50') self.assertTrue(str(u2.get_canonical_root()) == 'x-pyslet:') u = uri.URI('X-Pyslet:50%2f50#Frag') u2 = u.canonicalize() self.assertTrue(str(u2) == 'x-pyslet:50%2f50#Frag') self.assertTrue(str(u.get_canonical_root()) == 'x-pyslet:') u = uri.URI("x-pyslet://host/path") self.assertTrue(str(u.get_canonical_root()) == 'x-pyslet://host') u = uri.URI("x-pyslet:/path") self.assertTrue(str(u.get_canonical_root()) == 'x-pyslet:') u = uri.URI("/path") self.assertTrue(u.get_canonical_root() is None)
def visit_method(self, dirname, names): d = uri.URI.from_path(os.path.join(dirname, os.curdir)) c = sys.getfilesystemencoding() for name in names: if name.startswith('??'): logging.warn("8-bit path tests limited to ASCII file names " "by %s encoding", c) continue join_match = os.path.join(dirname, name) if is_unicode(name): seg_name = uri.escape_data( name.encode(c), uri.is_path_segment_reserved) else: seg_name = uri.escape_data(name, uri.is_path_segment_reserved) u = uri.URI(seg_name) u = u.resolve(d) self.assertTrue(isinstance(u, uri.FileURL)) joined = u.get_pathname() if isinstance(join_match, bytes) and is_unicode(joined): # if we're walking in 8-bit mode we need to downgrade to # compare joined = joined.encode(c) self.assertTrue(joined == join_match, "Joined pathnames mismatch:\n%s\n%s" % (joined, join_match))
def test_scheme(self): u = uri.URI(SIMPLE_EXAMPLE) self.assertTrue(u.is_absolute(), "Absolute test") self.assertTrue(u.scheme == 'http', "Scheme") self.assertTrue(u.scheme_specific_part == '//www.example.com/') u = uri.URI(RELATIVE_EXAMPLE) self.assertFalse(u.is_absolute(), "Relative test") self.assertTrue(u.scheme is None, "relative scheme") self.assertTrue(u.scheme_specific_part is None) u = uri.URI("x-pyslet:") self.assertTrue(u.is_absolute(), "Relative test") self.assertTrue(u.scheme == 'x-pyslet', "scheme only scheme") self.assertTrue(u.scheme_specific_part == '') # missing authority u = uri.URI("x-pyslet:/just/a/path") self.assertTrue(u.is_absolute(), "Relative test") self.assertTrue(u.abs_path == "/just/a/path", "abs path only") # missing abs path u = uri.URI("x-pyslet://host?just-a-query") self.assertTrue(u.is_absolute(), "Relative test") self.assertTrue(u.abs_path is None, "abs path only") self.assertTrue(u.query == "just-a-query", "abs path only") self.assertTrue(str(u) == "x-pyslet://host?just-a-query") # relative authority u = uri.URI("//host/just/a/path") self.assertFalse(u.is_absolute(), "Relative test") self.assertTrue(u.abs_path == "/just/a/path", "abs path only") # relative missing abs path u = uri.URI("//host?just-a-query") self.assertFalse(u.is_absolute(), "Relative test") self.assertTrue(u.abs_path is None, "no abs path") self.assertTrue(u.query == "just-a-query", "abs path only") self.assertTrue(str(u) == "//host?just-a-query")
def test_relative_examples(self): keys = REL_EXAMPLES.keys() base = uri.URI(REL_BASE) current = uri.URI(REL_CURRENT) relatives = {} for k in keys: logging.info("Testing relative: %s", k) u = uri.URI(k) resolved, scheme, authority, abs_path, rel_path, query, \ fragment = REL_EXAMPLES[k] relatives[resolved] = relatives.get(resolved, []) + [k] resolution = str(u.resolve(base, current)) self.assertTrue(scheme == u.scheme, "%s found scheme %s" % (k, u.scheme)) self.assertTrue(authority == u.authority, "%s found authority %s" % (k, u.authority)) self.assertTrue(abs_path == u.abs_path, "%s found abs_path %s" % (k, u.abs_path)) self.assertTrue(rel_path == u.rel_path, "%s found rel_path %s" % (k, u.rel_path)) self.assertTrue(query == u.query, "%s found query %s" % (k, u.query)) self.assertTrue(fragment == u.fragment, "%s found fragment %s" % (k, u.fragment)) self.assertTrue( resolved == resolution, "%s [*] %s = %s ; found %s" % (str(base), k, resolved, resolution)) for r in relatives.keys(): logging.info("Testing %s [/] %s = ( %s )", r, str(base), string.join(relatives[r], ' | ')) u = uri.URI(r) # this check removes the 'current document' case if not u.is_absolute(): continue relative = str(u.relative(base)) # relative should be one of the relatives! no_match = True for k in relatives[r]: if k == relative: no_match = False break self.assertFalse( no_match, "%s [/] %s = ( %s ) ; found %s" % (r, str(base), string.join(relatives[r], ' | '), relative))
def visit_method(self, dirname, names): # Make d a directory like path by adding an empty component at the end d = uri.URI.from_virtual_path(dirname.join(dirname.curdir)) for name in names: if unicode(name).startswith('??'): logging.warn("8-bit path tests limited to ASCII file names") continue join_match = dirname.join(name) seg_name = uri.escape_data( unicode(name).encode('utf-8'), uri.is_path_segment_reserved) u = uri.URI(seg_name) u = u.resolve(d) self.assertTrue(isinstance(u, uri.FileURL)) joined = u.get_virtual_file_path() self.assertTrue( joined == join_match, "Joined pathnames mismatch:\n%s\n%s" % (joined, join_match))
def test_absolute_examples(self): for k in dict_keys(ABS_EXAMPLES): logging.info("Testing absolute: %s", k) u = uri.URI(k) scheme, opaque_part, authority, abs_path, query, fName = \ ABS_EXAMPLES[k] self.assertTrue(scheme == u.scheme, "%s found scheme %s" % (k, u.scheme)) self.assertTrue(opaque_part == u.opaque_part, "%s found opaque_part %s" % (k, u.opaque_part)) self.assertTrue(authority == u.authority, "%s found authority %s" % (k, u.authority)) self.assertTrue(abs_path == u.abs_path, "%s found abs_path %s" % (k, u.abs_path)) self.assertTrue(query == u.query, "%s found query %s" % (k, u.query)) self.assertTrue(fName == u.get_file_name(), "%s found file name %s" % (k, u.get_file_name()))
def test_relative_join_examples(self): base1 = uri.URI(REL_BASE1) base2 = uri.URI(REL_BASE2) current = uri.URI(REL_CURRENT) relatives = {} for k in dict_keys(REL_EXAMPLES): u = uri.URI(k) if not u.octets: # don't test same document cases continue resolved, scheme, authority, abs_path, rel_path, query, \ fragment = REL_EXAMPLES[k] logging.info("Testing: %s [*] ( %s [*] %s ) = %s", str(base1), str(base2), k, resolved) # two-step resolution, first combines relative URLs, second # resolves to absolute resolution1 = u.resolve(base2, current) relatives[str(resolution1)] = relatives.get( str(resolution1), []) + [k] resolution2 = str(resolution1.resolve(base1, current)) self.assertTrue(scheme == u.scheme, "%s found scheme %s" % (k, u.scheme)) self.assertTrue(authority == u.authority, "%s found authority %s" % (k, u.authority)) self.assertTrue(abs_path == u.abs_path, "%s found abs_path %s" % (k, u.abs_path)) self.assertTrue(rel_path == u.rel_path, "%s found rel_path %s" % (k, u.rel_path)) self.assertTrue(query == u.query, "%s found query %s" % (k, u.query)) self.assertTrue(fragment == u.fragment, "%s found fragment %s" % (k, u.fragment)) self.assertTrue(resolved == resolution2, "%s [*] ( %s [*] %s ) = %s ; found %s" % (str(base1), str(base2), k, resolved, resolution2)) for r in dict_keys(relatives): logging.info("Testing: %s [/] %s = ( %s )", r, str(base2), ' | '.join(relatives[r])) u = uri.URI(r) # this check removes the 'current document' case if u.octets == 'current.doc': continue relative = str(u.relative(base2)) # now relative should be one of the relatives! no_match = True for k in relatives[r]: if k == relative: no_match = False break self.assertFalse(no_match, "%s [/] %s = ( %s ); found %s" % (r, str(base2), repr(relatives[r]), relative)) # catch a couple of odd cases not in the standard examples # U = B [*] R1 [*] R2 # R3 = R1 [*] R2 # R1 = ../a/b # R2 = ../../c/d # If B = /p/q/r/s, B [*] R1 = /p/q/a/b # So U = /p/q/a/b [*] ../../c/d = /p/c/d # So /p/c/d = /p/q/r/s [*] R3 # R3 = /p/c/d [/] /p/q/r/s # R3 = ../../c/d r1 = uri.URI('../a/b') r2 = uri.URI('../../c/d') r3 = uri.URI('../../c/d') self.assertTrue(str(r2.resolve(r1)) == str(r3)) # therefore it is possible for a (relative) base to start '..' self.assertTrue(str(r3.relative(r1)) == str(r2)) # but it should never be possible for the base to have more '..' # than the URL it resolves to, so check that raises an error try: rx = uri.URI('c/d').relative(r1) self.fail("c/d relative to ../a/b = " + str(rx)) except uri.URIException as e: logging.info("Too many parents: %s", str(e))