예제 #1
0
def test_filter_exclude():
    all_file_names = [
        "foo.py",
        "foo.go",
        "foo.java",
        "foo/bar.py",
        "foo/bar.go",
        "bar/foo/baz/bar.go",
        "foo/bar.java",
        "bar/baz",
        "baz.py",
        "baz.go",
        "baz.java",
        "bar/foo/foo.py",
        "foo",
        "bar/baz/foo/a.py",
        "bar/baz/foo/b.py",
        "bar/baz/foo/c.py",
        "bar/baz/qux/foo/a.py",
        "/foo/bar/baz/a.py",
    ]
    all_files = set({Path(elem) for elem in all_file_names})

    # Filter out .py files
    assert len(TargetManager.filter_excludes(all_files, ["*.py"])) == 9

    # Filter out files in a foo directory ancestor
    assert len(TargetManager.filter_excludes(all_files, ["foo"])) == 7

    # Filter out files with an ancestor named bar/baz
    assert len(TargetManager.filter_excludes(all_files, ["bar/baz"])) == 12

    # Filter out go files
    assert len(TargetManager.filter_excludes(all_files, ["*.go"])) == 14

    # Filter out go and java files
    assert len(TargetManager.filter_excludes(all_files,
                                             ["*.go", "*.java"])) == 11

    # Filter out go files with a direct ancestor named foo
    assert len(TargetManager.filter_excludes(all_files, ["foo/*.go"])) == 17
예제 #2
0
def test_filter_exclude():
    all_file_names = [
        "/foo/bar/baz/a.py",
        "bar/baz",
        "bar/baz/foo/a.py",
        "bar/baz/foo/b.py",
        "bar/baz/foo/c.py",
        "bar/baz/qux/foo/a.py",
        "bar/foo/baz/bar.go",
        "bar/foo/foo.py",
        "baz.go",
        "baz.java",
        "baz.py",
        "baz/foo",
        "foo",
        "foo.go",
        "foo.java",
        "foo.py",
        "foo/bar.go",
        "foo/bar.java",
        "foo/bar.py",
    ]
    all_files = frozenset({Path(elem) for elem in all_file_names})

    # Filter out .py files
    assert TargetManager.filter_excludes(all_files, ["*.py"]) == {
        Path(p)
        for p in [
            "bar/baz",
            "bar/foo/baz/bar.go",
            "baz.go",
            "baz.java",
            "baz/foo",
            "foo",
            "foo.go",
            "foo.java",
            "foo/bar.go",
            "foo/bar.java",
        ]
    }

    # Filter out go files
    assert TargetManager.filter_excludes(all_files, ["*.go"]) == {
        Path(p)
        for p in [
            "/foo/bar/baz/a.py",
            "bar/baz",
            "bar/baz/foo/a.py",
            "bar/baz/foo/b.py",
            "bar/baz/foo/c.py",
            "bar/baz/qux/foo/a.py",
            "bar/foo/foo.py",
            "baz.java",
            "baz.py",
            "baz/foo",
            "foo",
            "foo.java",
            "foo.py",
            "foo/bar.java",
            "foo/bar.py",
        ]
    }

    # Filter out go and java files
    assert TargetManager.filter_excludes(all_files, ["*.go", "*.java"]) == {
        Path(p)
        for p in [
            "/foo/bar/baz/a.py",
            "bar/baz",
            "bar/baz/foo/a.py",
            "bar/baz/foo/b.py",
            "bar/baz/foo/c.py",
            "bar/baz/qux/foo/a.py",
            "bar/foo/foo.py",
            "baz.py",
            "baz/foo",
            "foo",
            "foo.py",
            "foo/bar.py",
        ]
    }

    # Filter out files named foo or in a foo directory ancestor
    assert TargetManager.filter_excludes(all_files, ["foo"]) == {
        Path(p)
        for p in [
            "bar/baz",
            "baz.go",
            "baz.java",
            "baz.py",
            "foo.go",
            "foo.java",
            "foo.py",
        ]
    }

    # Filter out files with an ancestor named bar/baz
    assert TargetManager.filter_excludes(all_files, ["bar/baz"]) == {
        Path(p)
        for p in [
            "bar/foo/baz/bar.go",
            "bar/foo/foo.py",
            "baz.go",
            "baz.java",
            "baz.py",
            "baz/foo",
            "foo",
            "foo.go",
            "foo.java",
            "foo.py",
            "foo/bar.go",
            "foo/bar.java",
            "foo/bar.py",
        ]
    }

    # Filter out go files with a direct ancestor named foo
    assert TargetManager.filter_excludes(all_files, ["foo/*.go"]) == {
        Path(p)
        for p in [
            "/foo/bar/baz/a.py",
            "bar/baz",
            "bar/baz/foo/a.py",
            "bar/baz/foo/b.py",
            "bar/baz/foo/c.py",
            "bar/baz/qux/foo/a.py",
            "bar/foo/baz/bar.go",
            "bar/foo/foo.py",
            "baz.go",
            "baz.java",
            "baz.py",
            "baz/foo",
            "foo",
            "foo.go",
            "foo.java",
            "foo.py",
            "foo/bar.java",
            "foo/bar.py",
        ]
    }

    # Filter out go files with a ancestor named foo
    assert TargetManager.filter_excludes(all_files, ["foo/**/*.go"]) == {
        Path(p)
        for p in [
            "/foo/bar/baz/a.py",
            "bar/baz",
            "bar/baz/foo/a.py",
            "bar/baz/foo/b.py",
            "bar/baz/foo/c.py",
            "bar/baz/qux/foo/a.py",
            "bar/foo/foo.py",
            "baz.go",
            "baz.java",
            "baz.py",
            "baz/foo",
            "foo",
            "foo.go",
            "foo.java",
            "foo.py",
            "foo/bar.java",
            "foo/bar.py",
        ]
    }

    # Filter out py files with three-characters name
    assert TargetManager.filter_excludes(all_files, ["???.py"]) == {
        Path(p)
        for p in [
            "/foo/bar/baz/a.py",
            "bar/baz",
            "bar/baz/foo/a.py",
            "bar/baz/foo/b.py",
            "bar/baz/foo/c.py",
            "bar/baz/qux/foo/a.py",
            "bar/foo/baz/bar.go",
            "baz.go",
            "baz.java",
            "baz/foo",
            "foo",
            "foo.go",
            "foo.java",
            "foo/bar.go",
            "foo/bar.java",
        ]
    }