287 lines
9.5 KiB
Python
287 lines
9.5 KiB
Python
"""unit tests for glob_match"""
|
|
|
|
load("@bazel_skylib//lib:partial.bzl", "partial")
|
|
load("@bazel_skylib//lib:unittest.bzl", "asserts", "unittest")
|
|
load("//lib:glob_match.bzl", "glob_match", "is_glob")
|
|
|
|
def _glob_match_test(ctx, expr, matches, non_matches, mps_matches = None, mps_non_matches = None):
|
|
"""`mps sands for `match path segment`
|
|
"""
|
|
env = unittest.begin(ctx)
|
|
|
|
if mps_matches == None:
|
|
mps_matches = matches
|
|
|
|
if mps_non_matches == None:
|
|
mps_non_matches = non_matches
|
|
|
|
for path in matches:
|
|
asserts.equals(env, True, glob_match(expr, path), "Expected expr '{}' to match on path '{}'".format(expr, path))
|
|
|
|
for path in non_matches:
|
|
asserts.equals(env, False, glob_match(expr, path), "Expected expr '{}' to _not_ match on path '{}'".format(expr, path))
|
|
|
|
for path in mps_matches:
|
|
asserts.equals(env, True, glob_match(expr, path, match_path_separator = True), "Expected expr '{}' with match_path_separator to match on path '{}'".format(expr, path))
|
|
|
|
for path in mps_non_matches:
|
|
asserts.equals(env, False, glob_match(expr, path, match_path_separator = True), "Expected expr '{}' with match_path_separator to _not_ match on path '{}'".format(expr, path))
|
|
|
|
return unittest.end(env)
|
|
|
|
def _basic(ctx):
|
|
env = unittest.begin(ctx)
|
|
|
|
asserts.equals(env, True, glob_match("a", "a"), "single directory")
|
|
asserts.equals(env, True, glob_match("a/", "a/"), "trailing slash single directory")
|
|
asserts.equals(env, True, glob_match("/a", "/a"), "leading slash single directory")
|
|
asserts.equals(env, True, glob_match("/a/", "/a/"), "leading slash and trailing slash single directory")
|
|
|
|
asserts.equals(env, True, glob_match("a/b", "a/b"), "nested directory")
|
|
asserts.equals(env, True, glob_match("a/b/", "a/b/"), "trailing slash nested directory")
|
|
asserts.equals(env, True, glob_match("/a/b", "/a/b"), "leading slash nested directory")
|
|
asserts.equals(env, True, glob_match("/a/b/", "/a/b/"), "leading and trailing slash nested directory")
|
|
|
|
return unittest.end(env)
|
|
|
|
basic_test = unittest.make(_basic)
|
|
|
|
def _star(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"*",
|
|
matches = ["express"],
|
|
non_matches = ["@eslint/plugin-foo"],
|
|
mps_matches = ["express", "@eslint/plugin-foo"],
|
|
mps_non_matches = [],
|
|
)
|
|
|
|
star_test = unittest.make(_star)
|
|
|
|
def _trailing_star(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"x/*",
|
|
matches = ["x/y", "x/y.z"],
|
|
non_matches = ["x", "x/y/z"],
|
|
mps_matches = ["x/y/z"],
|
|
mps_non_matches = ["x"],
|
|
)
|
|
|
|
trailing_star_test = unittest.make(_trailing_star)
|
|
|
|
def _globstar(ctx):
|
|
return _glob_match_test(ctx, "**", ["@eslint/plugin-foo", "express"], [])
|
|
|
|
globstar_test = unittest.make(_globstar)
|
|
|
|
def _globstar_slash(ctx):
|
|
return _glob_match_test(ctx, "**/*", ["@eslint/plugin-foo", "express"], [])
|
|
|
|
globstar_slash_test = unittest.make(_globstar_slash)
|
|
|
|
def _qmark(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"?",
|
|
matches = ["a", "b"],
|
|
non_matches = ["/", "aa", "bb"],
|
|
mps_matches = ["a", "b", "/"],
|
|
mps_non_matches = ["aa", "bb"],
|
|
)
|
|
|
|
qmark_test = unittest.make(_qmark)
|
|
|
|
def _qmark_qmark(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"??",
|
|
matches = ["aa", "ba"],
|
|
non_matches = ["/", "a", "b"],
|
|
)
|
|
|
|
qmark_qmark_test = unittest.make(_qmark_qmark)
|
|
|
|
def _wrapped_qmark(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"f?n",
|
|
matches = ["fun", "fin"],
|
|
non_matches = ["funny", "fit", "bob", "f/n"],
|
|
mps_matches = ["fun", "fin", "f/n"],
|
|
mps_non_matches = ["funny", "fit", "bob"],
|
|
)
|
|
|
|
wrapped_qmark_test = unittest.make(_wrapped_qmark)
|
|
|
|
def _mixed_wrapped_qmark(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"f?n*",
|
|
matches = ["fun", "fin", "funny"],
|
|
non_matches = ["fit", "bob", "f/n", "f/n/uny"],
|
|
mps_matches = ["fun", "fin", "f/n", "funny", "f/n/uny"],
|
|
mps_non_matches = ["fit", "bob"],
|
|
)
|
|
|
|
mixed_wrapped_qmark_test = unittest.make(_mixed_wrapped_qmark)
|
|
|
|
def _leading_star_test(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"*/foo.*",
|
|
matches = ["fum/foo.x", "a/foo.bcd"],
|
|
non_matches = ["foo.x", "a/b/foo.x", "a/foo"],
|
|
mps_matches = ["fum/foo.x", "a/b/foo.x", "a/foo.bcd"],
|
|
mps_non_matches = ["foo.x", "a/foo"],
|
|
)
|
|
|
|
leading_star_test = unittest.make(_leading_star_test)
|
|
|
|
def _ending_star(ctx):
|
|
return _glob_match_test(ctx, "eslint-*", ["eslint-plugin-foo"], ["@eslint/plugin-foo", "express", "eslint", "-eslint"])
|
|
|
|
ending_star_test = unittest.make(_ending_star)
|
|
|
|
def _wrapping_star(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"*plugin*",
|
|
matches = ["eslint-plugin-foo"],
|
|
non_matches = ["@eslint/plugin-foo", "express"],
|
|
mps_matches = ["eslint-plugin-foo", "@eslint/plugin-foo"],
|
|
mps_non_matches = ["express"],
|
|
)
|
|
|
|
wrapping_star_test = unittest.make(_wrapping_star)
|
|
|
|
def _wrapped_star(ctx):
|
|
return _glob_match_test(ctx, "a*c", ["ac", "abc", "accc", "acacac", "a1234c", "a12c34c"], ["abcd"])
|
|
|
|
wrapped_star_test = unittest.make(_wrapped_star)
|
|
|
|
def _starting_star(ctx):
|
|
return _glob_match_test(ctx, "*-positive", ["is-positive"], ["is-positive-not"])
|
|
|
|
starting_star_test = unittest.make(_starting_star)
|
|
|
|
def _mixed_trailing_globstar(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"foo*/**",
|
|
matches = ["foo/fum/bar", "foostar/fum/bar", "foo/a", "foob/c", "foo/", "fooa/"],
|
|
non_matches = ["fo/fum/bar", "fostar/fum/bar", "foo", "foostar", "afoo", "b/foo/c"],
|
|
)
|
|
|
|
mixed_trailing_globstar_test = unittest.make(_mixed_trailing_globstar)
|
|
|
|
def _mixed_leading_globstar(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"**/foo*",
|
|
matches = ["fum/bar/foo", "fum/bar/foostar", "foo", "foostar", "as/foo"],
|
|
non_matches = ["fum/bar/fo", "fum/bar/fostar"],
|
|
)
|
|
|
|
mixed_leading_globstar_test = unittest.make(_mixed_leading_globstar)
|
|
|
|
def _mixed_leading_globstar2(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"**/*foo",
|
|
matches = ["fum/bar/foo", "fum/bar/starfoo", "foo", "xfoo"],
|
|
non_matches = ["fum/bar/foox", "fum/bar/foo/y"],
|
|
)
|
|
|
|
mixed_leading_globstar2_test = unittest.make(_mixed_leading_globstar2)
|
|
|
|
def _mixed_wrapping_globstar(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"**/foo*/**",
|
|
matches = ["fum/bar/foo/fum/bar", "fum/bar/foostar/fum/bar", "foo/a", "foob/c", "foo/"],
|
|
non_matches = ["fum/bar/fo/fum/bar", "fum/bar/fostar/fum/bar", "foo", "foostar"],
|
|
)
|
|
|
|
mixed_wrapper_globstar_test = unittest.make(_mixed_wrapping_globstar)
|
|
|
|
def _all_of_ext(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"**/*.tf",
|
|
matches = ["a.tf", "a/b.tf", "ab/cd/e.tf"],
|
|
non_matches = ["a/b.tfg", "a/tf", "a/b.tf/g"], #TODO: "a/.tf", ".tf"
|
|
)
|
|
|
|
all_of_ext_test = unittest.make(_all_of_ext)
|
|
|
|
def _all_of_name(ctx):
|
|
return _glob_match_test(
|
|
ctx,
|
|
"**/foo",
|
|
matches = ["a/b/c/foo", "foo/foo", "a/foo/foo", "foo"],
|
|
non_matches = ["foox", "foo/x"],
|
|
)
|
|
|
|
all_of_name_test = unittest.make(_all_of_name)
|
|
|
|
def _is_glob(ctx):
|
|
env = unittest.begin(ctx)
|
|
|
|
asserts.equals(env, False, is_glob(""))
|
|
asserts.equals(env, False, is_glob("/"))
|
|
asserts.equals(env, False, is_glob("."))
|
|
asserts.equals(env, False, is_glob("./"))
|
|
asserts.equals(env, False, is_glob(".."))
|
|
asserts.equals(env, False, is_glob("../"))
|
|
asserts.equals(env, False, is_glob("/./."))
|
|
asserts.equals(env, False, is_glob("/../."))
|
|
asserts.equals(env, False, is_glob("/a/b/c/d"))
|
|
asserts.equals(env, False, is_glob("/a/."))
|
|
|
|
asserts.equals(env, True, is_glob("*"))
|
|
asserts.equals(env, True, is_glob("**"))
|
|
asserts.equals(env, True, is_glob("?"))
|
|
asserts.equals(env, True, is_glob("/*"))
|
|
asserts.equals(env, True, is_glob("/**"))
|
|
asserts.equals(env, True, is_glob("/?"))
|
|
asserts.equals(env, True, is_glob(".*"))
|
|
asserts.equals(env, True, is_glob(".?"))
|
|
asserts.equals(env, True, is_glob("./foo/**/bar"))
|
|
asserts.equals(env, True, is_glob("*.txt"))
|
|
asserts.equals(env, True, is_glob("a/?.txt"))
|
|
|
|
return unittest.end(env)
|
|
|
|
is_glob_test = unittest.make(_is_glob)
|
|
|
|
def glob_match_test_suite():
|
|
unittest.suite(
|
|
"glob_match",
|
|
partial.make(basic_test, timeout = "short"),
|
|
partial.make(star_test, timeout = "short"),
|
|
partial.make(trailing_star_test, timeout = "short"),
|
|
partial.make(globstar_test, timeout = "short"),
|
|
partial.make(globstar_slash_test, timeout = "short"),
|
|
partial.make(qmark_test, timeout = "short"),
|
|
partial.make(qmark_qmark_test, timeout = "short"),
|
|
partial.make(wrapped_qmark_test, timeout = "short"),
|
|
partial.make(mixed_wrapped_qmark_test, timeout = "short"),
|
|
partial.make(leading_star_test, timeout = "short"),
|
|
partial.make(ending_star_test, timeout = "short"),
|
|
partial.make(wrapping_star_test, timeout = "short"),
|
|
partial.make(wrapped_star_test, timeout = "short"),
|
|
partial.make(all_of_ext_test, timeout = "short"),
|
|
partial.make(all_of_name_test, timeout = "short"),
|
|
partial.make(starting_star_test, timeout = "short"),
|
|
partial.make(mixed_trailing_globstar_test, timeout = "short"),
|
|
partial.make(mixed_leading_globstar_test, timeout = "short"),
|
|
partial.make(mixed_leading_globstar2_test, timeout = "short"),
|
|
partial.make(mixed_wrapper_globstar_test, timeout = "short"),
|
|
)
|
|
|
|
unittest.suite(
|
|
"is_glob",
|
|
partial.make(is_glob_test, timeout = "short"),
|
|
)
|