jit-utils-backend 0.0.1__py3-none-any.whl

tests/test_qrcode_barcode.py

@@ -0,0 +1,182 @@
+# -*-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

@@ -0,0 +1,174 @@
+# -*-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

@@ -0,0 +1,185 @@
+# -*-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()