chore: filecmp add unittest

Author: fatelei

Lib/filecmp.py

@@ -304,10 +304,12 @@ def _filter(flist, skip):
 
 # Demonstration and testing.
 #
-def demo():
+def demo(args=None):
     import sys
     import getopt
-    options, args = getopt.getopt(sys.argv[1:], 'r')
+
+    args = sys.argv[1:] if args is None else args
+    options, args = getopt.getopt(args, 'r')
     if len(args) != 2:
         raise getopt.GetoptError('need exactly two args', None)
     dd = dircmp(args[0], args[1])

Lib/test/test_filecmp.py

@@ -1,4 +1,5 @@
 import filecmp
+import getopt
 import os
 import re
 import shutil
@@ -21,7 +22,9 @@ def _create_file_shallow_equal(template_path, new_path):
     assert os.stat(new_path).st_size == os.stat(template_path).st_size
     assert os.stat(new_path).st_mtime == os.stat(template_path).st_mtime
 
+
 class FileCompareTestCase(unittest.TestCase):
+
     def setUp(self):
         self.name = os_helper.TESTFN
         self.name_same = os_helper.TESTFN + '-same'
@@ -367,5 +370,175 @@ def _assert_report(self, dircmp_report, expected_report_lines):
             self.assertEqual(report_lines, expected_report_lines)
 
 
+class TestFilecmpCLI(unittest.TestCase):
+    """Test the command line interface of filecmp module"""
+    
+    @classmethod
+    def setUpClass(cls):
+        cls.temp_dir = tempfile.mkdtemp()
+        cls.dir1 = os.path.join(cls.temp_dir, 'dir1')
+        cls.dir2 = os.path.join(cls.temp_dir, 'dir2')
+        os.makedirs(cls.dir1)
+        os.makedirs(cls.dir2)
+    
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.temp_dir)
+    
+    def tearDown(self):
+        # Clean up any files created in individual tests
+        for item in os.listdir(self.dir1):
+            path = os.path.join(self.dir1, item)
+            if os.path.isfile(path):
+                os.unlink(path)
+            elif os.path.isdir(path):
+                shutil.rmtree(path)
+        for item in os.listdir(self.dir2):
+            path = os.path.join(self.dir2, item)
+            if os.path.isfile(path):
+                os.unlink(path)
+            elif os.path.isdir(path):
+                shutil.rmtree(path)
+
+    def test_demo_basic_comparison(self):
+        """Test basic directory comparison via demo()"""
+        # Create test files for this test
+        with open(os.path.join(self.dir1, 'same.txt'), 'w') as f:
+            f.write('same content')
+        with open(os.path.join(self.dir2, 'same.txt'), 'w') as f:
+            f.write('same content')
+            
+        with open(os.path.join(self.dir1, 'different.txt'), 'w') as f:
+            f.write('content in dir1')
+        with open(os.path.join(self.dir2, 'different.txt'), 'w') as f:
+            f.write('content in dir2')
+            
+        with open(os.path.join(self.dir1, 'only_in_dir1.txt'), 'w') as f:
+            f.write('unique to dir1')
+            
+        with open(os.path.join(self.dir2, 'only_in_dir2.txt'), 'w') as f:
+            f.write('unique to dir2')
+        
+        with support.captured_stdout() as stdout:
+            filecmp.demo([self.dir1, self.dir2])
+            output = stdout.getvalue()
+        
+        # Check that output contains expected comparison results
+        self.assertIn('diff', output)
+        self.assertIn('same.txt', output)
+        self.assertIn('different.txt', output)
+        self.assertIn('only_in_dir1.txt', output)
+        self.assertIn('only_in_dir2.txt', output)
+
+    def test_demo_recursive_comparison(self):
+        """Test recursive directory comparison via demo() with -r flag"""
+        # Create subdirectories and files for recursive test
+        subdir1 = os.path.join(self.dir1, 'subdir')
+        subdir2 = os.path.join(self.dir2, 'subdir')
+        os.makedirs(subdir1)
+        os.makedirs(subdir2)
+        
+        with open(os.path.join(subdir1, 'subfile.txt'), 'w') as f:
+            f.write('sub content')
+        with open(os.path.join(subdir2, 'subfile.txt'), 'w') as f:
+            f.write('sub content')
+        
+        with support.captured_stdout() as stdout:
+            filecmp.demo(['-r', self.dir1, self.dir2])
+            output = stdout.getvalue()
+
+        # Check that output contains subdirectory comparison
+        self.assertIn('subdir', output)
+        self.assertIn('subfile.txt', output)
+
+    def test_demo_long_flag(self):
+        """Test demo with long --recursive flag (should fail as only -r is supported)"""
+        with self.assertRaises(getopt.GetoptError):
+            filecmp.demo(['--recursive', self.dir1, self.dir2])
+
+    def test_demo_no_arguments(self):
+        """Test demo with no arguments (should raise GetoptError)"""
+        with self.assertRaises(getopt.GetoptError) as cm:
+            filecmp.demo([])
+        self.assertIn('need exactly two args', str(cm.exception))
+
+    def test_demo_one_argument(self):
+        """Test demo with only one directory argument (should raise GetoptError)"""
+        with self.assertRaises(getopt.GetoptError) as cm:
+            filecmp.demo([self.dir1])
+        self.assertIn('need exactly two args', str(cm.exception))
+
+    def test_demo_three_arguments(self):
+        """Test demo with three arguments (should raise GetoptError)"""
+        with self.assertRaises(getopt.GetoptError) as cm:
+            filecmp.demo([self.dir1, self.dir2, 'extra'])
+        self.assertIn('need exactly two args', str(cm.exception))
+
+    def test_demo_nonexistent_directory(self):
+        """Test demo with nonexistent directory"""
+        # This should raise an exception during comparison
+        with self.assertRaises((FileNotFoundError, OSError)):
+            filecmp.demo([self.dir1, '/nonexistent/path'])
+
+    def test_demo_identical_directories(self):
+        """Test demo with identical directories"""
+        dir3 = os.path.join(self.temp_dir, 'dir3')
+        dir4 = os.path.join(self.temp_dir, 'dir4')
+        os.makedirs(dir3)
+        os.makedirs(dir4)
+
+        with open(os.path.join(dir3, 'file1.txt'), 'w') as f:
+            f.write('same content')
+        with open(os.path.join(dir4, 'file1.txt'), 'w') as f:
+            f.write('same content')
+
+        try:
+            with support.captured_stdout() as stdout:
+                filecmp.demo([dir3, dir4])
+                output = stdout.getvalue()
+
+            # Should indicate identical files
+            self.assertIn('Identical files', output)
+            self.assertIn('file1.txt', output)
+        finally:
+            # Clean up the extra directories
+            shutil.rmtree(dir3)
+            shutil.rmtree(dir4)
+
+    def test_demo_empty_directories(self):
+        """Test demo with empty directories"""
+        dir3 = os.path.join(self.temp_dir, 'empty1')
+        dir4 = os.path.join(self.temp_dir, 'empty2')
+        os.makedirs(dir3)
+        os.makedirs(dir4)
+
+        try:
+            with support.captured_stdout() as stdout:
+                filecmp.demo([dir3, dir4])
+                output = stdout.getvalue()
+
+            # Should handle empty directories gracefully
+            self.assertTrue(len(output) > 0)
+        finally:
+            # Clean up the extra directories
+            shutil.rmtree(dir3)
+            shutil.rmtree(dir4)
+
+    def test_demo_with_files_instead_of_directories(self):
+        """Test demo when file paths are given instead of directories"""
+        file1 = os.path.join(self.dir1, 'same.txt')
+        file2 = os.path.join(self.dir2, 'same.txt')
+        
+        # Create the files first
+        with open(file1, 'w') as f:
+            f.write('content')
+        with open(file2, 'w') as f:
+            f.write('content')
+
+        # This should raise an exception as files are not directories
+        with self.assertRaises((NotADirectoryError, OSError)):
+            filecmp.demo([file1, file2])
+
+
 if __name__ == "__main__":
     unittest.main()