Add comprehensive unit test suite for configuration-related modules (#6)

* Create tests folder and __init__.py

* Implement and run tests/test_utils.py

* Implement and run tests/test_copy_bettergi_config.py

* Implement and run tests/test_launcher.py

* Implement and run tests/test_generate_onedragon_config.py

* Refactor test suites based on Code Review feedback

* Apply code review styling suggestions to tests

* Finalize CI workflow and address styling/robustness feedback

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

Author: Copilot

.github/workflows/ci.yml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pyyaml
+
+      - name: Compile Python files
+        run: |
+          python -m compileall -q .
+
+      - name: Run tests
+        run: |
+          python -m unittest discover -s tests -p 'test*.py'

tests/__init__.py

@@ -0,0 +1 @@
+# Test package for OneDragon-Helper

tests/test_copy_bettergi_config.py

@@ -0,0 +1,95 @@
+import os
+import unittest
+import tempfile
+import yaml
+import shutil
+from unittest.mock import patch
+import copy_bettergi_config
+
+class TestCopyBettergiConfig(unittest.TestCase):
+
+    def setUp(self):
+        # Create a temporary directory structure for our tests
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp_dir.cleanup)
+        
+        # Paths for mock config, mock BGI sources, etc.
+        self.mock_config_path = os.path.join(self.temp_dir.name, "config.yml")
+        self.mock_our_bgi_dir = os.path.join(self.temp_dir.name, "BGI_User")
+        os.makedirs(self.mock_our_bgi_dir, exist_ok=True)
+        
+        # Put a dummy file inside mock_our_bgi_dir to test file copying
+        with open(os.path.join(self.mock_our_bgi_dir, "test_file.json"), "w") as f:
+            f.write('{"test": true}')
+
+    @patch('copy_bettergi_config.get_onedragon_yml_path_under_root')
+    def test_get_BGI_user_dir_success(self, mock_get_yml):
+        mock_get_yml.return_value = self.mock_config_path
+        
+        # Case 1: '原神' exists in script_list
+        config_data = {
+            'script_list': [
+                {
+                    'display_name': '鸣潮',
+                    'script_path': 'C:\\Games\\ok-ww\\ok-ww.exe'
+                },
+                {
+                    'display_name': '原神',
+                    'script_path': os.path.join(self.temp_dir.name, 'BetterGI', 'BetterGI.exe')
+                }
+            ]
+        }
+        with open(self.mock_config_path, 'w', encoding='utf-8') as f:
+            yaml.dump(config_data, f)
+            
+        res = copy_bettergi_config.get_BGI_user_dir()
+        expected = os.path.join(self.temp_dir.name, 'BetterGI', 'User')
+        self.assertEqual(os.path.normpath(res), os.path.normpath(expected))
+
+    @patch('copy_bettergi_config.get_onedragon_yml_path_under_root')
+    def test_get_BGI_user_dir_not_found(self, mock_get_yml):
+        mock_get_yml.return_value = self.mock_config_path
+        
+        # Case 2: '原神' does not exist in script_list
+        config_data = {
+            'script_list': [
+                {
+                    'display_name': '鸣潮',
+                    'script_path': 'C:\\Games\\ok-ww\\ok-ww.exe'
+                }
+            ]
+        }
+        with open(self.mock_config_path, 'w', encoding='utf-8') as f:
+            yaml.dump(config_data, f)
+            
+        res = copy_bettergi_config.get_BGI_user_dir()
+        self.assertIsNone(res)
+
+    @patch('copy_bettergi_config.get_our_bgi_user_dir')
+    @patch('copy_bettergi_config.get_BGI_user_dir')
+    def test_copy_BGI_config(self, mock_get_bgi, mock_get_our_bgi):
+        target_dir = os.path.join(self.temp_dir.name, 'TargetBGI', 'User')
+        
+        mock_get_our_bgi.return_value = self.mock_our_bgi_dir
+        mock_get_bgi.return_value = target_dir
+        
+        # Ensure target_dir does not exist yet
+        self.assertFalse(os.path.exists(target_dir))
+        
+        copy_bettergi_config.copy_BGI_config()
+        
+        # Verify copying actually occurred
+        self.assertTrue(os.path.exists(os.path.join(target_dir, "test_file.json")))
+        with open(os.path.join(target_dir, "test_file.json"), "r") as f:
+            self.assertEqual(f.read(), '{"test": true}')
+
+    @patch('copy_bettergi_config.get_BGI_user_dir')
+    @patch('shutil.copytree')
+    def test_copy_BGI_config_none(self, mock_copytree, mock_get_bgi):
+        mock_get_bgi.return_value = None
+        
+        copy_bettergi_config.copy_BGI_config()
+        mock_copytree.assert_not_called()
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_generate_onedragon_config.py

@@ -0,0 +1,89 @@
+import os
+import sys
+import unittest
+import tempfile
+import shutil
+from unittest.mock import patch, MagicMock
+
+# Global reference to target module and original modules dictionary
+generate_onedragon_config = None
+original_modules = {}
+
+def setUpModule():
+    global generate_onedragon_config
+    # Mock PySide6 and qfluentwidgets to avoid ModuleNotFoundError when importing generate_onedragon_config
+    for mod in ['PySide6', 'PySide6.QtWidgets', 'PySide6.QtGui', 'qfluentwidgets']:
+        original_modules[mod] = sys.modules.get(mod)
+        sys.modules[mod] = MagicMock()
+    
+    import generate_onedragon_config as goc
+    generate_onedragon_config = goc
+
+def tearDownModule():
+    # Restore original modules to avoid affecting other tests in the same process
+    for mod, orig in original_modules.items():
+        if orig is None:
+            sys.modules.pop(mod, None)
+        else:
+            sys.modules[mod] = orig
+
+class TestGenerateOnedragonConfig(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp_dir.cleanup)
+        
+        # Create temp source directory and target directory
+        self.src_dir = os.path.join(self.temp_dir.name, "python_script")
+        self.dest_dir = os.path.join(self.temp_dir.name, "scripts")
+        os.makedirs(self.src_dir, exist_ok=True)
+        os.makedirs(self.dest_dir, exist_ok=True)
+        
+        # Create a dummy script file in source
+        self.dummy_script_name = "test_script.py"
+        with open(os.path.join(self.src_dir, self.dummy_script_name), "w") as f:
+            f.write("# Dummy python script")
+
+    @patch('generate_onedragon_config.get_path_under_root')
+    @patch('generate_onedragon_config.get_path_under_onedragon')
+    def test_copy_python_scripts_not_exists(self, mock_get_path, mock_get_root):
+        mock_get_root.return_value = self.src_dir
+        mock_get_path.return_value = self.dest_dir
+        
+        # The file does not exist in destination yet
+        self.assertFalse(os.path.exists(os.path.join(self.dest_dir, self.dummy_script_name)))
+        
+        generate_onedragon_config.copy_python_scripts()
+        
+        # Verify file is copied
+        self.assertTrue(os.path.exists(os.path.join(self.dest_dir, self.dummy_script_name)))
+
+    @patch('generate_onedragon_config.get_path_under_root')
+    @patch('generate_onedragon_config.get_path_under_onedragon')
+    @patch('shutil.copy')
+    def test_copy_python_scripts_already_exists(self, mock_copy, mock_get_path, mock_get_root):
+        mock_get_root.return_value = self.src_dir
+        mock_get_path.return_value = self.dest_dir
+        
+        # Pre-create the file in destination
+        with open(os.path.join(self.dest_dir, self.dummy_script_name), "w") as f:
+            f.write("# Pre-existing script")
+            
+        generate_onedragon_config.copy_python_scripts()
+        
+        # shutil.copy should not be called
+        mock_copy.assert_not_called()
+
+    @patch('generate_onedragon_config.copy_python_scripts')
+    @patch('generate_onedragon_config.run_config_ui')
+    @patch('generate_onedragon_config.get_onedragon_yml_path_under_root')
+    def test_config_workflow(self, mock_get_yml, mock_run_ui, mock_copy):
+        mock_get_yml.return_value = "/mock/config.yml"
+        
+        generate_onedragon_config.config_workflow()
+        
+        mock_copy.assert_called_once()
+        mock_run_ui.assert_called_once_with("/mock/config.yml")
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_launcher.py

@@ -0,0 +1,113 @@
+import os
+import unittest
+import tempfile
+import yaml
+import copy
+from unittest.mock import patch, MagicMock
+import launcher
+
+class TestLauncher(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp_dir.cleanup)
+        
+        # Paths
+        self.mock_root_dir = os.path.join(self.temp_dir.name, "root")
+        self.mock_onedragon_dir = os.path.join(self.temp_dir.name, "onedragon")
+        os.makedirs(self.mock_root_dir, exist_ok=True)
+        os.makedirs(self.mock_onedragon_dir, exist_ok=True)
+        
+        self.config_yml_path = os.path.join(self.mock_root_dir, "config.yml")
+        
+        # Mock configuration data
+        self.config_data = {
+            'script_list': [
+                {
+                    'display_name': 'Test Script 1',
+                    # Timeout values corresponding to Mon (100) through Sun (700), i.e., indices 0-6
+                    'weekly_timeouts': [100, 200, 300, 400, 500, 600, 700],
+                    'run_timeout_seconds': 0
+                },
+                {
+                    'display_name': 'Test Script 2 (No timeouts)',
+                    'run_timeout_seconds': 50
+                }
+            ]
+        }
+        with open(self.config_yml_path, 'w', encoding='utf-8') as f:
+            yaml.dump(self.config_data, f)
+
+    def test_get_week_num(self):
+        wk = launcher.get_week_num()
+        self.assertIsInstance(wk, int)
+        self.assertTrue(0 <= wk <= 6)
+
+    @patch('launcher.get_week_num')
+    @patch('launcher.get_root_dir')
+    @patch('launcher.get_path_under_onedragon')
+    def test_generate_OneDragon_script_chain_success(self, mock_get_path, mock_get_root, mock_get_week):
+        mock_get_root.return_value = self.mock_root_dir
+        
+        # Create output directory for script_chain config
+        out_dir = os.path.join(self.mock_onedragon_dir, "config", "script_chain")
+        os.makedirs(out_dir, exist_ok=True)
+        mock_get_path.return_value = out_dir
+        
+        # Test for Wednesday (weekday index 2)
+        wednesday_index = 2
+        wednesday_timeout = 300
+        mock_get_week.return_value = wednesday_index
+        
+        launcher.generate_OneDragon_script_chain()
+        
+        output_file = os.path.join(out_dir, "01.yml")
+        self.assertTrue(os.path.exists(output_file))
+        
+        with open(output_file, 'r', encoding='utf-8') as f:
+            output_data = yaml.safe_load(f)
+            
+        # Assertions
+        scripts = output_data.get('script_list', [])
+        self.assertEqual(scripts[0]['run_timeout_seconds'], wednesday_timeout)
+        self.assertEqual(scripts[1]['run_timeout_seconds'], 50)  # Unchanged since no weekly_timeouts
+
+    @patch('launcher.get_week_num')
+    @patch('launcher.get_root_dir')
+    @patch('launcher.get_path_under_onedragon')
+    def test_generate_OneDragon_script_chain_invalid_timeout_length(self, mock_get_path, mock_get_root, mock_get_week):
+        mock_get_root.return_value = self.mock_root_dir
+        out_dir = os.path.join(self.mock_onedragon_dir, "config", "script_chain")
+        os.makedirs(out_dir, exist_ok=True)
+        mock_get_path.return_value = out_dir
+        mock_get_week.return_value = 0
+        
+        # Write config with wrong timeout list size (6 instead of 7)
+        invalid_config = copy.deepcopy(self.config_data)
+        invalid_config['script_list'][0]['weekly_timeouts'] = [100, 200, 300, 400, 500, 600]
+        with open(self.config_yml_path, 'w', encoding='utf-8') as f:
+            yaml.dump(invalid_config, f)
+            
+        with self.assertRaises(AssertionError):
+            launcher.generate_OneDragon_script_chain()
+
+    @patch('launcher.get_path_under_onedragon')
+    @patch('subprocess.run')
+    def test_run_launcher(self, mock_run, mock_get_path):
+        mock_get_path.return_value = "/mock/src/dir"
+        
+        mock_res = MagicMock()
+        mock_res.returncode = 123
+        mock_run.return_value = mock_res
+        
+        ret = launcher.run_launcher()
+        
+        self.assertEqual(ret, 123)
+        mock_get_path.assert_called_once_with("src")
+        mock_run.assert_called_once()
+        args, kwargs = mock_run.call_args
+        self.assertEqual(kwargs['cwd'], "/mock/src/dir")
+        self.assertIn("script_chainer.win_exe.launcher", args[0])
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_utils.py

@@ -0,0 +1,58 @@
+import os
+import unittest
+import tempfile
+from unittest.mock import patch
+import utils
+
+class TestUtils(unittest.TestCase):
+
+    def test_get_root_dir(self):
+        root_dir = utils.get_root_dir()
+        self.assertTrue(os.path.isabs(root_dir))
+        self.assertTrue(os.path.isdir(root_dir))
+
+    def test_get_our_bgi_user_dir(self):
+        bgi_user_dir = utils.get_our_bgi_user_dir()
+        root_dir = utils.get_root_dir()
+        self.assertEqual(bgi_user_dir, os.path.join(root_dir, "BGI_User"))
+
+    def test_get_onedragon_yml_path_under_root(self):
+        yml_path = utils.get_onedragon_yml_path_under_root()
+        root_dir = utils.get_root_dir()
+        self.assertEqual(yml_path, os.path.join(root_dir, "config.yml"))
+
+    def test_get_path_under_root(self):
+        # Without subdirs
+        path = utils.get_path_under_root()
+        self.assertEqual(path, utils.get_root_dir())
+        
+        # With subdirs (using mock to avoid actually creating it if it doesn't exist)
+        with patch('utils.join_dir_path_with_mk') as mock_join:
+            mock_join.return_value = "mock_path"
+            res = utils.get_path_under_root("sub1", "sub2")
+            self.assertEqual(res, "mock_path")
+            mock_join.assert_called_once_with(utils.get_root_dir(), "sub1", "sub2")
+
+    def test_get_path_under_onedragon(self):
+        with patch('utils.join_dir_path_with_mk') as mock_join:
+            mock_join.return_value = "mock_path"
+            res = utils.get_path_under_onedragon("sub1")
+            self.assertEqual(res, "mock_path")
+            mock_join.assert_called_once_with(utils.get_root_dir(), "OneDragon-ScriptChainer", "sub1")
+
+    def test_join_dir_path_with_mk(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Let's test joining normal subdirectories
+            res = utils.join_dir_path_with_mk(temp_dir, "sub1", "sub2")
+            expected = os.path.normpath(os.path.join(temp_dir, "sub1", "sub2"))
+            self.assertEqual(os.path.normpath(res), expected)
+            self.assertTrue(os.path.isdir(expected))
+            
+            # Let's test handling None in subs
+            res_none = utils.join_dir_path_with_mk(temp_dir, "sub3", None, "sub4")
+            expected_none = os.path.normpath(os.path.join(temp_dir, "sub3", "sub4"))
+            self.assertEqual(os.path.normpath(res_none), expected_none)
+            self.assertTrue(os.path.isdir(expected_none))
+
+if __name__ == "__main__":
+    unittest.main()