jit-utils-backend 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

jit_utils/__init__.py

@@ -20,5 +20,5 @@ A comprehensive utility package for backend development with JIT.
     ...
 """
 
-__version__ = '0.0.2'
+__version__ = '0.0.3'
 __author__ = 'zangtao'

{jit_utils_backend-0.0.2.dist-info → jit_utils_backend-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jit-utils-backend
-Version: 0.0.2
+Version: 0.0.3
 Summary: 极态后端工具包
 Author: JitAi
 Author-email: develop@wanyunapp.com
@@ -180,4 +180,4 @@ zangtao (noguchisyou123456@gmail.com)
 
 ## 版本
 
-0.0.2
+0.0.3

{jit_utils_backend-0.0.2.dist-info → jit_utils_backend-0.0.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-jit_utils/__init__.py,sha256=jAB2jCgY7I9OSPIRBWmMIuxsWoVAqRFALnZxm73_EsY,473
+jit_utils/__init__.py,sha256=uiOH1XdTzqKkXJZ0B5RbTZzJCP0Yvl5l48Lu2rmIRH8,473
 jit_utils/apiAuthSign.py,sha256=TzYe3tDVQw0LYcE82IPcibtt_qyGTJ3XbWVjti5lGx0,2323
 jit_utils/barcode.py,sha256=PuSHqxttr4rOGMAfojK7Ii72z4CoqxUQR_hmMOaElN8,1102
 jit_utils/clsTool.py,sha256=tfMy3ITwfbfBLE6cjTrrRwMWB0aFh4fAYGJBZJ3vmCE,2316
@@ -20,13 +20,7 @@ jit_utils/config/case.py,sha256=sFs5NvFaga7lbjlSDRwMKkufiIEYFSYSG3ha8PB1-58,2591
 jit_utils/config/config.py,sha256=kH0u0eTwQR0shS0KwYd9f8c9uDxKPyjxYpYQ0rKZLXc,2713
 jit_utils/config/exception.py,sha256=wrok-q14bTl8afClYgX649F2Qk0vrwl6LiWGgpkKDY0,378
 jit_utils/config/field.py,sha256=5cq0M7zAtJrFkEHQ2H-1x95ypQxMyg07JjHnIAzSPQg,4759
-tests/__init__.py,sha256=Feh5oxeLX-QAsWdK7XteVUZkQR1uZMfByvrB-Em0FEk,60
-tests/run_tests.py,sha256=_0YG9MQCLkl18U-y-3BoI_KVbCZyGhMyPtLrOygAwVw,2959
-tests/test_package_imports.py,sha256=av8vhbx_VZUdWFMffWE5XKlu5glXE8LtzgmQvNsp0wo,6994
-tests/test_qrcode_barcode.py,sha256=RD08MCLHap0tb8hiXyrlkkdnK6t1Ij0p6gdCrJWqCIg,6598
-tests/test_string_utils.py,sha256=i1Q98PwMrPbjc4nkb1O3Z4pwvu0SMZrSOYbgDdeU4D4,5845
-tests/test_time_utils.py,sha256=nl9k_g0HmILHYTANMMRQgOF_vO4qGkfMzs6XiEJEnYA,6944
-jit_utils_backend-0.0.2.dist-info/METADATA,sha256=3m1frtfoG_EKKM0EaUcaIsRbbs6GFA8gjn1y61NY6Ow,3710
-jit_utils_backend-0.0.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-jit_utils_backend-0.0.2.dist-info/top_level.txt,sha256=SvmeRMPwBF2UwUtkhHAzXWSPhwVATqN2FFmZp2pJHjA,16
-jit_utils_backend-0.0.2.dist-info/RECORD,,
+jit_utils_backend-0.0.3.dist-info/METADATA,sha256=_O6Fe1jHYjVuDRmariTZttqI0tH9ul_DEClQRIJSwAI,3710
+jit_utils_backend-0.0.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+jit_utils_backend-0.0.3.dist-info/top_level.txt,sha256=r9DXZkwpqwiisjnpeWfLj01h_M6yxlF_DvjprlPJmco,10
+jit_utils_backend-0.0.3.dist-info/RECORD,,

{jit_utils_backend-0.0.2.dist-info → jit_utils_backend-0.0.3.dist-info}/top_level.txt

@@ -1,2 +1 @@
 jit_utils
-tests

tests/__init__.py

@@ -1,4 +0,0 @@
-# -*-coding:utf-8-*-
-"""
-JIT Utils Backend 测试套件
-""" 

tests/run_tests.py

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-# -*-coding:utf-8-*-
-"""
-JIT Utils Backend 测试运行器
-
-运行所有测试并生成报告
-"""
-import sys
-import unittest
-import os
-
-# 添加项目根目录到Python路径
-project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.insert(0, project_root)
-
-
-def run_all_tests():
-    """运行所有测试"""
-    # 发现测试目录中的所有测试
-    test_dir = os.path.dirname(os.path.abspath(__file__))
-    
-    # 创建测试套件
-    loader = unittest.TestLoader()
-    suite = loader.discover(test_dir, pattern='test_*.py')
-    
-    # 运行测试
-    runner = unittest.TextTestRunner(verbosity=2, stream=sys.stdout)
-    result = runner.run(suite)
-    
-    # 打印总结
-    print("\n" + "="*60)
-    print("测试总结:")
-    print(f"运行测试数: {result.testsRun}")
-    print(f"失败数: {len(result.failures)}")
-    print(f"错误数: {len(result.errors)}")
-    print(f"跳过数: {len(result.skipped)}")
-    
-    if result.failures:
-        print("\n失败的测试:")
-        for test, traceback in result.failures:
-            print(f"  - {test}: {traceback.split('AssertionError:')[-1].strip()}")
-    
-    if result.errors:
-        print("\n出错的测试:")
-        for test, traceback in result.errors:
-            print(f"  - {test}: {traceback.split('Error:')[-1].strip()}")
-    
-    if result.skipped:
-        print("\n跳过的测试:")
-        for test, reason in result.skipped:
-            print(f"  - {test}: {reason}")
-    
-    success_rate = ((result.testsRun - len(result.failures) - len(result.errors)) / result.testsRun * 100) if result.testsRun > 0 else 0
-    print(f"\n成功率: {success_rate:.1f}%")
-    
-    return result.wasSuccessful()
-
-
-def run_specific_test(test_name):
-    """运行特定的测试模块"""
-    test_dir = os.path.dirname(os.path.abspath(__file__))
-    
-    try:
-        # 动态导入测试模块
-        test_module = __import__(f'tests.{test_name}', fromlist=[test_name])
-        
-        # 创建测试套件
-        loader = unittest.TestLoader()
-        suite = loader.loadTestsFromModule(test_module)
-        
-        # 运行测试
-        runner = unittest.TextTestRunner(verbosity=2)
-        result = runner.run(suite)
-        
-        return result.wasSuccessful()
-        
-    except ImportError as e:
-        print(f"无法导入测试模块 '{test_name}': {e}")
-        return False
-
-
-def main():
-    """主函数"""
-    if len(sys.argv) > 1:
-        # 运行特定测试
-        test_name = sys.argv[1]
-        if not test_name.startswith('test_'):
-            test_name = f'test_{test_name}'
-        
-        print(f"运行测试模块: {test_name}")
-        success = run_specific_test(test_name)
-    else:
-        # 运行所有测试
-        print("运行所有测试...")
-        success = run_all_tests()
-    
-    # 根据测试结果设置退出码
-    sys.exit(0 if success else 1)
-
-
-if __name__ == '__main__':
-    main() 

tests/test_package_imports.py

@@ -1,190 +0,0 @@
-# -*-coding:utf-8-*-
-"""
-测试包的子模块导入功能
-"""
-import unittest
-
-
-class TestPackageImports(unittest.TestCase):
-    """包导入测试类"""
-    
-    def test_main_package_import(self):
-        """测试主包导入"""
-        try:
-            import jit_utils
-            self.assertTrue(hasattr(jit_utils, '__version__'))
-            self.assertTrue(hasattr(jit_utils, '__author__'))
-            self.assertEqual(jit_utils.__version__, '0.0.2')
-            self.assertEqual(jit_utils.__author__, 'zangtao')
-        except ImportError as e:
-            self.fail(f"主包导入失败: {e}")
-    
-    def test_string_module_import(self):
-        """测试字符串模块导入"""
-        try:
-            from jit_utils.string import randomString, getUuidStr, md5Str
-            
-            # 测试函数是否可调用
-            self.assertTrue(callable(randomString))
-            self.assertTrue(callable(getUuidStr))
-            self.assertTrue(callable(md5Str))
-            
-            # 简单功能测试
-            random_str = randomString(6)
-            self.assertEqual(len(random_str), 6)
-            
-            uuid_str = getUuidStr()
-            self.assertEqual(len(uuid_str), 32)
-            
-            md5_hash = md5Str("test")
-            self.assertEqual(len(md5_hash), 32)
-            
-        except ImportError as e:
-            self.skipTest(f"字符串模块导入失败: {e}")
-    
-    def test_time_module_import(self):
-        """测试时间模块导入"""
-        try:
-            from jit_utils.time import now, getTimestamp, formatNow
-            
-            # 测试函数是否可调用
-            self.assertTrue(callable(now))
-            self.assertTrue(callable(getTimestamp))
-            self.assertTrue(callable(formatNow))
-            
-            # 简单功能测试
-            current_time = now()
-            self.assertIsNotNone(current_time)
-            
-            timestamp = getTimestamp()
-            self.assertIsInstance(timestamp, (int, float))
-            
-            formatted_time = formatNow()
-            self.assertIsInstance(formatted_time, str)
-            
-        except ImportError as e:
-            self.skipTest(f"时间模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_qrcode_module_import(self):
-        """测试二维码模块导入"""
-        try:
-            from jit_utils.qrcode import Qrcode
-            
-            # 测试类是否可实例化
-            self.assertTrue(callable(Qrcode))
-            
-            # 创建实例
-            qr = Qrcode("test")
-            self.assertEqual(qr.value, "test")
-            
-        except ImportError as e:
-            self.skipTest(f"二维码模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_barcode_module_import(self):
-        """测试条形码模块导入"""
-        try:
-            from jit_utils.barcode import Barcode
-            
-            # 测试类是否可实例化
-            self.assertTrue(callable(Barcode))
-            
-            # 创建实例
-            bc = Barcode("123456789")
-            self.assertEqual(bc.value, "123456789")
-            
-        except ImportError as e:
-            self.skipTest(f"条形码模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_validator_module_import(self):
-        """测试验证器模块导入"""
-        try:
-            from jit_utils.validator import ParamsValidator
-            self.assertTrue(callable(ParamsValidator))
-        except ImportError as e:
-            self.skipTest(f"验证器模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_network_module_import(self):
-        """测试网络模块导入"""
-        try:
-            import jit_utils.network
-            # 网络模块应该可以导入
-            self.assertIsNotNone(jit_utils.network)
-        except ImportError as e:
-            self.skipTest(f"网络模块导入失败: {e}")
-    
-    def test_signature_module_import(self):
-        """测试签名模块导入"""
-        try:
-            import jit_utils.signature
-            self.assertIsNotNone(jit_utils.signature)
-        except ImportError as e:
-            self.skipTest(f"签名模块导入失败: {e}")
-    
-    def test_exceptions_module_import(self):
-        """测试异常模块导入"""
-        try:
-            import jit_utils.exceptions
-            self.assertIsNotNone(jit_utils.exceptions)
-        except ImportError as e:
-            self.skipTest(f"异常模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_config_module_import(self):
-        """测试配置模块导入"""
-        try:
-            import jit_utils.config
-            self.assertIsNotNone(jit_utils.config)
-        except ImportError as e:
-            self.skipTest(f"配置模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_workday_constants_import(self):
-        """测试工作日常量导入"""
-        try:
-            import jit_utils.workday_constants
-            self.assertIsNotNone(jit_utils.workday_constants)
-            # 检查是否有工作日相关的常量
-            self.assertTrue(hasattr(jit_utils.workday_constants, 'holidayDict') or 
-                          hasattr(jit_utils.workday_constants, 'workdayDict'))
-        except ImportError as e:
-            self.skipTest(f"工作日常量模块导入失败: {e}")
-    
-    def test_decorator_import(self):
-        """测试装饰器导入"""
-        try:
-            from jit_utils.decorator import forward
-            self.assertTrue(callable(forward))
-        except ImportError as e:
-            self.skipTest(f"装饰器模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_convert_module_import(self):
-        """测试转换器模块导入"""
-        try:
-            from jit_utils.convert import Converter, MemoryCompiler
-            self.assertTrue(callable(Converter))
-            self.assertTrue(callable(MemoryCompiler))
-        except ImportError as e:
-            self.skipTest(f"转换器模块导入失败（可能缺少依赖）: {e}")
-    
-    def test_package_structure(self):
-        """测试包结构"""
-        import jit_utils
-        
-        # 检查主要模块是否存在
-        modules_to_check = [
-            'string', 'time', 'qrcode', 'barcode', 'validator',
-            'network', 'signature', 'exceptions', 'config',
-            'workday_constants', 'decorator', 'convert'
-        ]
-        
-        for module_name in modules_to_check:
-            try:
-                # 尝试导入模块
-                __import__(f'jit_utils.{module_name}')
-                # 如果导入成功，则通过测试
-                self.assertTrue(True, f"模块 {module_name} 可以导入")
-            except ImportError:
-                # 如果导入失败，跳过（可能是依赖问题）
-                self.skipTest(f"模块 {module_name} 导入失败（可能缺少依赖）")
-
-
-if __name__ == '__main__':
-    unittest.main() 

tests/test_qrcode_barcode.py

@@ -1,182 +0,0 @@
-# -*-coding:utf-8-*-
-"""
-测试二维码和条形码模块
-"""
-import unittest
-import base64
-import re
-
-
-class TestQrcodeBarcode(unittest.TestCase):
-    """二维码和条形码测试类"""
-    
-    def setUp(self):
-        """测试设置"""
-        try:
-            from jit_utils.qrcode import Qrcode
-            from jit_utils.barcode import Barcode
-            self.qrcode_available = True
-            self.barcode_available = True
-            self.Qrcode = Qrcode
-            self.Barcode = Barcode
-        except ImportError as e:
-            self.qrcode_available = False
-            self.barcode_available = False
-            self.import_error = str(e)
-    
-    def test_qrcode_creation(self):
-        """测试二维码创建"""
-        if not self.qrcode_available:
-            self.skipTest(f"二维码模块导入失败: {self.import_error}")
-        
-        # 创建二维码
-        qr = self.Qrcode("Hello World")
-        self.assertEqual(qr.value, "Hello World")
-        self.assertEqual(qr.row, 200)  # 默认行数
-        self.assertEqual(qr.col, 200)  # 默认列数
-        
-        # 自定义尺寸
-        qr_custom = self.Qrcode("Test", row=300, col=300)
-        self.assertEqual(qr_custom.row, 300)
-        self.assertEqual(qr_custom.col, 300)
-    
-    def test_qrcode_toByte(self):
-        """测试二维码转字节"""
-        if not self.qrcode_available:
-            self.skipTest(f"二维码模块导入失败: {self.import_error}")
-        
-        qr = self.Qrcode("Hello World")
-        try:
-            byte_data = qr.toByte()
-            self.assertIsInstance(byte_data, bytes)
-            self.assertGreater(len(byte_data), 0)
-        except Exception as e:
-            self.skipTest(f"二维码生成失败: {str(e)}")
-    
-    def test_qrcode_toStr(self):
-        """测试二维码转base64字符串"""
-        if not self.qrcode_available:
-            self.skipTest(f"二维码模块导入失败: {self.import_error}")
-        
-        # 测试正常值
-        qr = self.Qrcode("Hello World")
-        try:
-            str_data = qr.toStr()
-            self.assertIsInstance(str_data, str)
-            self.assertTrue(str_data.startswith("<image:"))
-            self.assertTrue(str_data.endswith(">"))
-            
-            # 提取base64部分
-            base64_part = str_data[7:-1]  # 去掉 "<image:" 和 ">"
-            # 验证是否为有效的base64
-            base64.b64decode(base64_part)  # 如果无效会抛出异常
-        except Exception as e:
-            self.skipTest(f"二维码字符串生成失败: {str(e)}")
-        
-        # 测试空值
-        qr_empty = self.Qrcode("")
-        result = qr_empty.toStr()
-        self.assertEqual(result, "")
-    
-    def test_qrcode_str_method(self):
-        """测试二维码__str__方法"""
-        if not self.qrcode_available:
-            self.skipTest(f"二维码模块导入失败: {self.import_error}")
-        
-        qr = self.Qrcode("Test")
-        try:
-            str_result = str(qr)
-            expected = qr.toStr()
-            self.assertEqual(str_result, expected)
-        except Exception as e:
-            self.skipTest(f"二维码__str__方法失败: {str(e)}")
-    
-    def test_barcode_creation(self):
-        """测试条形码创建"""
-        if not self.barcode_available:
-            self.skipTest(f"条形码模块导入失败: {self.import_error}")
-        
-        # 创建条形码
-        bc = self.Barcode("123456789")
-        self.assertEqual(bc.value, "123456789")
-        self.assertEqual(bc.codeType, "code128")  # 默认类型
-        
-        # 自定义类型
-        bc_custom = self.Barcode("123456789", "code39")
-        self.assertEqual(bc_custom.codeType, "code39")
-    
-    def test_barcode_toByte(self):
-        """测试条形码转字节"""
-        if not self.barcode_available:
-            self.skipTest(f"条形码模块导入失败: {self.import_error}")
-        
-        bc = self.Barcode("123456789")
-        try:
-            byte_data = bc.toByte()
-            self.assertIsInstance(byte_data, bytes)
-            self.assertGreater(len(byte_data), 0)
-        except Exception as e:
-            self.skipTest(f"条形码生成失败: {str(e)}")
-    
-    def test_barcode_toStr(self):
-        """测试条形码转base64字符串"""
-        if not self.barcode_available:
-            self.skipTest(f"条形码模块导入失败: {self.import_error}")
-        
-        # 测试正常值
-        bc = self.Barcode("123456789")
-        try:
-            str_data = bc.toStr()
-            self.assertIsInstance(str_data, str)
-            
-            # 如果成功，应该是base64格式
-            if not str_data.startswith("ERROR:"):
-                self.assertTrue(str_data.startswith("<image:"))
-                self.assertTrue(str_data.endswith(">"))
-                
-                # 提取base64部分
-                base64_part = str_data[7:-1]  # 去掉 "<image:" 和 ">"
-                # 验证是否为有效的base64
-                base64.b64decode(base64_part)
-        except Exception as e:
-            self.skipTest(f"条形码字符串生成失败: {str(e)}")
-        
-        # 测试空值
-        bc_empty = self.Barcode("")
-        result = bc_empty.toStr()
-        self.assertEqual(result, "")
-    
-    def test_barcode_invalid_data(self):
-        """测试条形码无效数据处理"""
-        if not self.barcode_available:
-            self.skipTest(f"条形码模块导入失败: {self.import_error}")
-        
-        # 测试可能导致错误的数据
-        bc = self.Barcode("invalid_barcode_data!@#$%^&*()")
-        try:
-            result = bc.toStr()
-            # 如果出错，应该返回ERROR:开头的字符串
-            if result.startswith("ERROR:"):
-                self.assertIn("ERROR:", result)
-            else:
-                # 如果没出错，应该是正常的base64格式
-                self.assertTrue(result.startswith("<image:"))
-        except Exception as e:
-            self.skipTest(f"条形码错误处理测试失败: {str(e)}")
-    
-    def test_barcode_str_method(self):
-        """测试条形码__str__方法"""
-        if not self.barcode_available:
-            self.skipTest(f"条形码模块导入失败: {self.import_error}")
-        
-        bc = self.Barcode("123456789")
-        try:
-            str_result = str(bc)
-            expected = bc.toStr()
-            self.assertEqual(str_result, expected)
-        except Exception as e:
-            self.skipTest(f"条形码__str__方法失败: {str(e)}")
-
-
-if __name__ == '__main__':
-    unittest.main() 

tests/test_string_utils.py

@@ -1,174 +0,0 @@
-# -*-coding:utf-8-*-
-"""
-测试字符串工具模块
-"""
-import unittest
-import re
-import os
-import tempfile
-from jit_utils.string import (
-    randomString, randomNum, getUuidStr, md5Bytes, md5Str, 
-    lowercase, capitalize, getFileMd5, getRandomField, getRandom,
-    genrSublist, renderTemplateString
-)
-
-
-class TestStringUtils(unittest.TestCase):
-    """字符串工具测试类"""
-    
-    def test_randomString(self):
-        """测试随机字符串生成"""
-        # 测试默认长度
-        result = randomString()
-        self.assertEqual(len(result), 8)
-        self.assertTrue(result.isalnum())
-        
-        # 测试自定义长度
-        result = randomString(12)
-        self.assertEqual(len(result), 12)
-        self.assertTrue(result.isalnum())
-        
-        # 测试两次生成的结果不同（概率很高）
-        result1 = randomString(20)
-        result2 = randomString(20)
-        self.assertNotEqual(result1, result2)
-    
-    def test_randomNum(self):
-        """测试随机数字生成"""
-        # 测试默认6位数字
-        result = randomNum()
-        self.assertEqual(len(result), 6)
-        self.assertTrue(result.isdigit())
-        
-        # 测试自定义位数
-        result = randomNum(4)
-        self.assertEqual(len(result), 4)
-        self.assertTrue(result.isdigit())
-        
-        # 测试两次生成的结果不同（概率很高）
-        result1 = randomNum(8)
-        result2 = randomNum(8)
-        self.assertNotEqual(result1, result2)
-    
-    def test_getUuidStr(self):
-        """测试UUID字符串生成"""
-        result = getUuidStr()
-        # UUID去掉连字符后应该是32位十六进制字符串
-        self.assertEqual(len(result), 32)
-        self.assertTrue(re.match(r'^[a-f0-9]{32}$', result))
-        
-        # 测试两次生成的UUID不同
-        result1 = getUuidStr()
-        result2 = getUuidStr()
-        self.assertNotEqual(result1, result2)
-    
-    def test_md5Bytes(self):
-        """测试字节数据MD5加密"""
-        test_data = b"hello world"
-        result = md5Bytes(test_data)
-        expected = "5eb63bbbe01eeed093cb22bb8f5acdc3"
-        self.assertEqual(result, expected)
-        
-        # 测试空字节
-        result = md5Bytes(b"")
-        expected = "d41d8cd98f00b204e9800998ecf8427e"
-        self.assertEqual(result, expected)
-    
-    def test_md5Str(self):
-        """测试字符串MD5加密"""
-        test_str = "hello world"
-        result = md5Str(test_str)
-        expected = "5eb63bbbe01eeed093cb22bb8f5acdc3"
-        self.assertEqual(result, expected)
-        
-        # 测试不同编码
-        result = md5Str("你好", "utf-8")
-        self.assertEqual(len(result), 32)
-        self.assertTrue(re.match(r'^[a-f0-9]{32}$', result))
-    
-    def test_lowercase(self):
-        """测试首字母小写"""
-        self.assertEqual(lowercase("Hello"), "hello")
-        self.assertEqual(lowercase("WORLD"), "wORLD")
-        self.assertEqual(lowercase("a"), "a")
-        self.assertEqual(lowercase(""), "")
-    
-    def test_capitalize(self):
-        """测试首字母大写"""
-        self.assertEqual(capitalize("hello"), "Hello")
-        self.assertEqual(capitalize("world"), "World")
-        self.assertEqual(capitalize("A"), "A")
-        self.assertEqual(capitalize(""), "")
-    
-    def test_getFileMd5(self):
-        """测试文件MD5计算"""
-        # 创建临时文件
-        with tempfile.NamedTemporaryFile(mode='w', delete=False) as f:
-            f.write("hello world")
-            temp_file = f.name
-        
-        try:
-            result = getFileMd5(temp_file)
-            expected = "5eb63bbbe01eeed093cb22bb8f5acdc3"
-            self.assertEqual(result, expected)
-        finally:
-            os.unlink(temp_file)
-        
-        # 测试不存在的文件
-        result = getFileMd5("non_existent_file.txt")
-        self.assertIsNone(result)
-    
-    def test_getRandomField(self):
-        """测试随机字段名生成"""
-        result = getRandomField()
-        self.assertTrue(result.startswith("fk"))
-        self.assertEqual(len(result), 6)  # "fk" + 4个字符
-        
-        result = getRandomField(6)
-        self.assertTrue(result.startswith("fk"))
-        self.assertEqual(len(result), 8)  # "fk" + 6个字符
-    
-    def test_getRandom(self):
-        """测试随机字符串生成（小写字母+数字）"""
-        result = getRandom()
-        self.assertEqual(len(result), 8)
-        self.assertTrue(re.match(r'^[a-z0-9]+$', result))
-        
-        result = getRandom(12)
-        self.assertEqual(len(result), 12)
-        self.assertTrue(re.match(r'^[a-z0-9]+$', result))
-    
-    def test_genrSublist(self):
-        """测试列表分割"""
-        test_list = list(range(10))
-        result = list(genrSublist(test_list, 3))
-        
-        expected = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]
-        self.assertEqual(result, expected)
-        
-        # 测试整除的情况
-        test_list = list(range(9))
-        result = list(genrSublist(test_list, 3))
-        expected = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
-        self.assertEqual(result, expected)
-    
-    def test_renderTemplateString(self):
-        """测试模板字符串渲染"""
-        template = "Hello {{name}}, you are {{age}} years old"
-        result = renderTemplateString(template, name="Alice", age=25)
-        expected = "Hello Alice, you are 25 years old"
-        self.assertEqual(result, expected)
-        
-        # 测试缺失变量
-        result = renderTemplateString("Hello {{name}}", age=25)
-        expected = "Hello "
-        self.assertEqual(result, expected)
-        
-        # 测试无变量
-        result = renderTemplateString("Hello World")
-        expected = "Hello World"
-        self.assertEqual(result, expected)
-
-
-if __name__ == '__main__':
-    unittest.main() 

tests/test_time_utils.py

@@ -1,185 +0,0 @@
-# -*-coding:utf-8-*-
-"""
-测试时间工具模块
-"""
-import unittest
-import datetime
-import time
-from unittest.mock import patch
-
-
-class TestTimeUtils(unittest.TestCase):
-    """时间工具测试类"""
-    
-    def setUp(self):
-        """测试设置"""
-        # 由于时间模块可能有导包问题，我们使用try-except来导入
-        try:
-            from jit_utils.time import (
-                getTimestamp, timeStampToDateTime, strToTimestamp,
-                formatNow, datetime2string, string2datetime,
-                timestamp2date, timestamp2string, cmpTsSameDay
-            )
-            self.time_module_available = True
-            self.getTimestamp = getTimestamp
-            self.timeStampToDateTime = timeStampToDateTime
-            self.strToTimestamp = strToTimestamp
-            self.formatNow = formatNow
-            self.datetime2string = datetime2string
-            self.string2datetime = string2datetime
-            self.timestamp2date = timestamp2date
-            self.timestamp2string = timestamp2string
-            self.cmpTsSameDay = cmpTsSameDay
-        except ImportError as e:
-            self.time_module_available = False
-            self.import_error = str(e)
-    
-    def test_getTimestamp(self):
-        """测试获取时间戳"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        timestamp = self.getTimestamp()
-        self.assertIsInstance(timestamp, int)
-        # 时间戳应该是13位数字（毫秒级）
-        self.assertGreater(timestamp, 1000000000000)
-        self.assertLess(timestamp, 9999999999999)
-    
-    def test_timeStampToDateTime(self):
-        """测试时间戳转datetime"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        try:
-            # 测试秒级时间戳
-            timestamp_sec = 1640995200  # 2022-01-01 00:00:00
-            result = self.timeStampToDateTime(timestamp_sec)
-            self.assertIsInstance(result, datetime.datetime)
-            self.assertEqual(result.year, 2022)
-            self.assertEqual(result.month, 1)
-            self.assertEqual(result.day, 1)
-            
-            # 测试毫秒级时间戳
-            timestamp_ms = 1640995200000
-            result = self.timeStampToDateTime(timestamp_ms)
-            self.assertIsInstance(result, datetime.datetime)
-            self.assertEqual(result.year, 2022)
-        except Exception as e:
-            self.skipTest(f"时间戳转换函数出错: {str(e)}")
-    
-    def test_formatNow(self):
-        """测试格式化当前时间"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        # 测试默认格式
-        result = self.formatNow()
-        self.assertIsInstance(result, str)
-        # 应该匹配 YYYY-MM-DD 格式
-        import re
-        self.assertTrue(re.match(r'^\d{4}-\d{2}-\d{2}$', result))
-        
-        # 测试自定义格式
-        result = self.formatNow("%Y%m%d")
-        self.assertTrue(re.match(r'^\d{8}$', result))
-    
-    def test_datetime2string(self):
-        """测试datetime转字符串"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        # 测试正常的datetime对象
-        dt = datetime.datetime(2022, 1, 1, 12, 30, 45)
-        result = self.datetime2string(dt)
-        expected = "2022-01-01"
-        self.assertEqual(result, expected)
-        
-        # 测试自定义格式
-        result = self.datetime2string(dt, "%Y-%m-%d %H:%M:%S")
-        expected = "2022-01-01 12:30:45"
-        self.assertEqual(result, expected)
-        
-        # 测试非datetime对象
-        result = self.datetime2string("not_datetime")
-        self.assertEqual(result, "")
-    
-    def test_string2datetime(self):
-        """测试字符串转datetime"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        # 测试默认格式
-        date_str = "2022-01-01"
-        result = self.string2datetime(date_str)
-        self.assertIsInstance(result, datetime.datetime)
-        self.assertEqual(result.year, 2022)
-        self.assertEqual(result.month, 1)
-        self.assertEqual(result.day, 1)
-        
-        # 测试自定义格式
-        date_str = "01/01/2022"
-        result = self.string2datetime(date_str, "%m/%d/%Y")
-        self.assertIsInstance(result, datetime.datetime)
-        self.assertEqual(result.year, 2022)
-    
-    def test_timestamp2date(self):
-        """测试时间戳转日期字符串"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        timestamp = 1640995200  # 2022-01-01 00:00:00
-        result = self.timestamp2date(timestamp)
-        self.assertEqual(result, "2022-01-01")
-    
-    def test_timestamp2string(self):
-        """测试时间戳转格式化字符串"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        timestamp = 1640995200000  # 毫秒级时间戳
-        result = self.timestamp2string(timestamp)
-        self.assertIsInstance(result, str)
-        # 应该包含日期和时间
-        self.assertIn("2022-01-01", result)
-        
-        # 测试自定义格式
-        result = self.timestamp2string(timestamp, "%Y%m%d")
-        self.assertEqual(result, "20220101")
-    
-    def test_cmpTsSameDay(self):
-        """测试比较两个时间戳是否同一天"""
-        if not self.time_module_available:
-            self.skipTest(f"时间模块导入失败: {self.import_error}")
-        
-        # 同一天的不同时间
-        ts1 = 1640995200000  # 2022-01-01 00:00:00
-        ts2 = 1641038400000  # 2022-01-01 12:00:00
-        result = self.cmpTsSameDay(ts1, ts2)
-        self.assertTrue(result)
-        
-        # 不同天
-        ts3 = 1641081600000  # 2022-01-02 00:00:00
-        result = self.cmpTsSameDay(ts1, ts3)
-        self.assertFalse(result)
-    
-    def test_basic_time_functions(self):
-        """测试基本时间函数（不依赖外部导入）"""
-        # 这些测试直接使用Python标准库，不依赖可能有问题的导入
-        
-        # 测试当前时间戳
-        now_ts = int(time.time() * 1000)
-        self.assertIsInstance(now_ts, int)
-        self.assertGreater(now_ts, 1000000000000)
-        
-        # 测试datetime操作
-        now_dt = datetime.datetime.now()
-        formatted = now_dt.strftime("%Y-%m-%d")
-        self.assertIsInstance(formatted, str)
-        
-        # 测试日期计算
-        tomorrow = now_dt + datetime.timedelta(days=1)
-        self.assertGreater(tomorrow, now_dt)
-
-
-if __name__ == '__main__':
-    unittest.main()