gh-117829 : added tests

Author: VietThan

Doc/library/zipapp.rst

@@ -96,12 +96,12 @@ The following options are understood:
 
 .. option:: --include
 
-   Accept glob-like filtering for files to be allowed in output archive. This will run
+   Accept glob-patterns filtering for files to be allowed in output archive. This will run
    first if :option:`--exclude` is also used.
 
 .. option:: --exclude
 
-   Accept glob-like filtering files to be denied inclusion in output archive. This will
+   Accept glob-patterns filtering files to be denied inclusion in output archive. This will
    run second if :option:`--include` is also used.
 
 

Lib/test/test_zipapp.py

@@ -395,6 +395,12 @@ def make_archive(self):
         target = self.tmpdir / 'source.pyz'
         zipapp.create_archive(source, target)
         return target
+    
+    def _make_tree(self, root: pathlib.Path, files: list[str]) -> None:
+        for rel in files:
+            p = root / rel
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.touch()
 
     def test_cmdline_create(self):
         # Test the basic command line API.
@@ -454,6 +460,134 @@ def test_info_error(self):
         # Program should exit with a non-zero return code.
         self.assertTrue(cm.exception.code)
 
+    def test_cmdline_include_then_exclude(self):
+        source = self.tmpdir / 'source'
+        source.mkdir()
+        self._make_tree(source, [
+            '__main__.py',
+            'foo/a.py',
+            'foo/b.pyc',
+            'bar/c.txt',
+        ])
+
+        # Include 'foo' (directory implies subtree), then exclude *.pyc
+        args = [
+            str(source),
+            '--include', '*.py',
+            '--include', 'foo', 
+            '--exclude', '**/*.pyc']
+        zipapp.main(args)
+
+        target = source.with_suffix('.pyz')
+        with zipfile.ZipFile(target, 'r') as z:
+            names = set(z.namelist())
+            # Always contains __main__.py unless overridden by -m
+            self.assertIn('__main__.py', names)
+            self.assertIn('foo/', names)
+            self.assertIn('foo/a.py', names)
+            # Excluded by pattern
+            self.assertNotIn('foo/b.pyc', names)
+            # Not included at all since include restricted to 'foo'
+            self.assertNotIn('bar/', names)
+            self.assertNotIn('bar/c.txt', names)
+
+    def test_cmdline_multiple_includes_commas_and_extend(self):
+        source = self.tmpdir / 'src'
+        source.mkdir()
+        self._make_tree(source, [
+            '__main__.py',
+            'pkg/x.py',
+            'pkg/y.txt',
+            'data/readme.txt',
+            'data/keep.bin',
+        ])
+
+        args = [
+            str(source),
+            '--include', 'pkg,data/*.txt',
+            '--include', 'data/keep.bin',
+        ]
+        zipapp.main(args)
+
+        target = source.with_suffix('.pyz')
+        with zipfile.ZipFile(target, 'r') as z:
+            names = set(z.namelist())
+            # did not include root files
+            self.assertNotIn('__main__.py', names)
+            # from "pkg"
+            self.assertIn('pkg/', names)
+            self.assertIn('pkg/x.py', names)
+            self.assertIn('pkg/y.txt', names)
+            # from "data/*.txt"
+            self.assertIn('data/readme.txt', names)
+            # from the second --include
+            self.assertIn('data/keep.bin', names)
+
+    def test_cmdline_exclude_directory_over_included_files(self):
+        source = self.tmpdir / 'tree'
+        source.mkdir()
+        self._make_tree(source, [
+            '__main__.py',
+            'foo/a.py',
+            'foo/b.py',
+            'bar/c.py',
+        ])
+
+        # Include all *.py, but exclude 'foo/**' entirely
+        args = [
+            str(source),
+            '--include', '*.py',
+            '--exclude', 'foo',
+        ]
+        zipapp.main(args)
+
+        target = source.with_suffix('.pyz')
+        with zipfile.ZipFile(target, 'r') as z:
+            names = set(z.namelist())
+            self.assertIn('__main__.py', names)
+            # foo is excluded even though files match *.py
+            self.assertNotIn('foo/', names)
+            self.assertNotIn('foo/a.py', names)
+            self.assertNotIn('foo/b.py', names)
+            # bar/c.py remains
+            self.assertIn('bar/c.py', names)
+
+    def test_cmdline_normalization_and_dir_implies_subtree(self):
+        source = self.tmpdir / 'norm'
+        source.mkdir()
+        self._make_tree(source, [
+            '__main__.py',
+            'a/b/c.txt',
+            'a/d/e.py',
+            'x/y/z.py',
+        ])
+
+        # Use Windows-style backslashes and a leading './'
+        # 'a\\b' should imply both 'a/b' and 'a/b/**'
+        args = [
+            str(source),
+            '--include', r'.\a\b',
+            '--include', r'a\d',         # also directory → subtree
+            '--exclude', '**/*.py',      # exclude all *.py after include
+        ]
+        zipapp.main(args)
+
+        target = source.with_suffix('.pyz')
+        with zipfile.ZipFile(target, 'r') as z:
+            names = set(z.namelist())
+            # did not include root files
+            self.assertNotIn('__main__.py', names)
+            # from a/b subtree, c.txt should be present
+            self.assertIn('a/b/', names)
+            self.assertIn('a/b/c.txt', names)
+            # from a/d subtree, e.py would match include but then be excluded by **/*.py
+            self.assertIn('a/d/', names)
+            self.assertNotIn('a/d/e.py', names)
+            # x/y/z.py not included at all (not in includes)
+            self.assertNotIn('x/', names)
+            self.assertNotIn('x/y/', names)
+            self.assertNotIn('x/y/z.py', names)
+
 
 if __name__ == "__main__":
     unittest.main()