Update readme

Author: zxdong262

.gitignore

@@ -158,4 +158,5 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
-/temp/
+/temp/
+/*.json

README.md

@@ -1,7 +1,11 @@
+[中文](README_zh.md)
+
 # Electerm sync server python
 
 [![Build Status](https://github.com/electerm/electerm-sync-server-python/actions/workflows/linux.yml/badge.svg)](https://github.com/electerm/electerm-sync-server-python/actions)
 
+
+
 A simple electerm data sync server with python.
 
 ## Use
@@ -11,6 +15,11 @@ Requires python3
 ```bash
 git clone git@github.com:electerm/electerm-sync-server-python.git
 cd electerm-sync-server-python
+python -m venv venv
+# On Windows (PowerShell):
+venv\Scripts\activate
+# On Unix/Mac:
+# source venv/bin/activate
 pip install -r requirements.txt
 
 # create env file, then edit .env

README_zh.md

@@ -0,0 +1,55 @@
+[English](README.md)
+
+# Electerm 同步服务器 Python 版
+
+[![Build Status](https://github.com/electerm/electerm-sync-server-python/actions/workflows/linux.yml/badge.svg)](https://github.com/electerm/electerm-sync-server-python/actions)
+
+一个简单的 Electerm 数据同步服务器，使用 Python。
+
+## 使用
+
+需要 Python 3
+
+```bash
+git clone git@github.com:electerm/electerm-sync-server-python.git
+cd electerm-sync-server-python
+python -m venv venv
+# 在 Windows (PowerShell) 上：
+venv\Scripts\activate
+# 在 Unix/Mac 上：
+# source venv/bin/activate
+pip install -r requirements.txt
+
+# 创建环境文件，然后编辑 .env
+cp sample.env .env
+
+python src/app.py
+
+# 会显示类似内容
+# server running at http://127.0.0.1:7837
+
+# 在 Electerm 同步设置中，设置自定义同步服务器：
+# 服务器 URL：http://127.0.0.1:7837
+# 然后你可以在 Electerm 自定义同步中使用 http://127.0.0.1:7837/api/sync 作为 API URL
+
+# JWT_SECRET：在 .env 中的 JWT_SECRET
+# JWT_USER_NAME：在 .env 中的一个 JWT_USER
+```
+
+## 测试
+
+```bash
+bin/test
+```
+
+## 编写自己的数据存储
+
+以 [src/file_store.py](src/file_store.py) 为例，编写自己的读写方法
+
+## 其他语言的同步服务器
+
+[https://github.com/electerm/electerm/wiki/Custom-sync-server](https://github.com/electerm/electerm/wiki/Custom-sync-server)
+
+---
+
+

bin/release

@@ -11,11 +11,24 @@
 app.config['JWT_IDENTITY_CLAIM'] = 'id'
 jwt = JWTManager(app)
 
-@app.route('/api/sync', methods=['GET', 'PUT'])
+@jwt.invalid_token_loader
+def invalid_token_callback(error_string):
+    return jsonify({'status': 'error', 'message': 'Invalid token'}), 422
+
+@jwt.expired_token_loader
+def expired_token_callback(jwt_header, jwt_payload):
+    return jsonify({'status': 'error', 'message': 'Token expired'}), 422
+
+@jwt.unauthorized_loader
+def unauthorized_callback(error_string):
+    return jsonify({'status': 'error', 'message': 'Missing or invalid token'}), 422
+
+@app.route('/api/sync', methods=['GET', 'PUT', 'POST'])
 @jwt_required()
 def sync():
     user_id = get_jwt_identity()
     users = os.environ['JWT_USERS'].split(',')
+    
     if user_id not in users:
         return jsonify({'status': 'error', 'message': 'Unauthorized!'}), 401
 

src/app.py

@@ -3,59 +3,179 @@
 import tempfile
 import os
 import sys
+import shutil
+from unittest.mock import patch
 from dotenv import load_dotenv
 
+# Load environment variables
 load_dotenv()
 sys.path.append(os.path.dirname(os.path.abspath(__file__)) + "/..")
 
+from src import file_store
 from src.file_store import read, write
 
-class TestExample(unittest.TestCase):
+class TestFileStore(unittest.TestCase):
 
     def setUp(self):
-        self.test_user_id = 'test_user_id'
-        self.test_data = {'key': 'value'}
+        # Create temporary directory for testing
+        self.temp_dir = tempfile.mkdtemp(prefix='test_file_store_')
 
-    def test_write(self):
-        # Use temporary file for testing
-        with tempfile.NamedTemporaryFile() as f:
+        # Set FILE_STORE_PATH to our temp directory
+        self.env_patcher = patch.dict(os.environ, {'FILE_STORE_PATH': self.temp_dir})
+        self.env_patcher.start()
 
-            # Write to file
-            write_status, write_code = write(self.test_data, self.test_user_id)
+        # Re-import file_store to pick up the new environment variable
+        import importlib
+        importlib.reload(file_store)
+        from src.file_store import read, write
+        globals()['read'] = read
+        globals()['write'] = write
 
-            # Test status and code
-            self.assertEqual(write_status, 'ok')
-            self.assertEqual(write_code, 200)
+        # Test data
+        self.test_user_id = 'testuser1'
+        self.test_data = {'key': 'value', 'data': [1, 2, 3]}
+        self.empty_data = {}
+        self.none_data = None
 
-            # Read from file
-            read_data, read_code = read(self.test_user_id)
+    def tearDown(self):
+        self.env_patcher.stop()
+        # Clean up temp directory
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
 
-            # Test read data and code
-            self.assertEqual(read_data, self.test_data)
-            self.assertEqual(read_code, 200)
+    def test_write_valid_data(self):
+        """Test writing valid data"""
+        status, code = write(self.test_data, self.test_user_id)
+        self.assertEqual(status, 'ok')
+        self.assertEqual(code, 200)
 
-    def test_read_not_found(self):
-        # Use temporary file for testing
-        with tempfile.TemporaryDirectory() as tempdir:
-            os.environ['FILE_STORE_PATH'] = tempdir
+        # Verify file was created and contains correct data
+        data, read_code = read(self.test_user_id)
+        self.assertEqual(read_code, 200)
+        self.assertEqual(data, self.test_data)
 
-            # Read from unexisting file
-            read_data, read_code = read(self.test_user_id + '0000')
+    def test_write_empty_data(self):
+        """Test writing empty dictionary"""
+        status, code = write(self.empty_data, self.test_user_id)
+        self.assertEqual(status, 'ok')
+        self.assertEqual(code, 200)
 
-            # Test not found data and code
-            self.assertEqual(read_data, 'File not found')
-            self.assertEqual(read_code, 404)
+        data, read_code = read(self.test_user_id)
+        self.assertEqual(read_code, 200)
+        self.assertEqual(data, {})
 
-    def test_read(self):
-        # Use temporary file for testing
-        with tempfile.TemporaryDirectory() as tempdir:
-            # Read from unexisting file
-            write(self.test_data, self.test_user_id)
-            read_data, read_code = read(self.test_user_id)
+    def test_write_none_data(self):
+        """Test writing None data (should be converted to empty dict)"""
+        status, code = write(self.none_data, self.test_user_id)
+        self.assertEqual(status, 'ok')
+        self.assertEqual(code, 200)
 
-            # Test not found data and code
-            self.assertEqual(read_data, self.test_data)
-            self.assertEqual(read_code, 200)
+        data, read_code = read(self.test_user_id)
+        self.assertEqual(read_code, 200)
+        self.assertEqual(data, {})
+
+    def test_write_complex_data(self):
+        """Test writing complex nested data"""
+        complex_data = {
+            'users': [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}],
+            'settings': {'theme': 'dark', 'notifications': True},
+            'timestamp': '2025-11-10T16:59:40'
+        }
+        status, code = write(complex_data, self.test_user_id)
+        self.assertEqual(status, 'ok')
+        self.assertEqual(code, 200)
+
+        data, read_code = read(self.test_user_id)
+        self.assertEqual(read_code, 200)
+        self.assertEqual(data, complex_data)
+
+    def test_read_existing_file(self):
+        """Test reading existing file"""
+        write(self.test_data, self.test_user_id)
+        data, code = read(self.test_user_id)
+        self.assertEqual(code, 200)
+        self.assertEqual(data, self.test_data)
+
+    def test_read_nonexistent_file(self):
+        """Test reading non-existent file"""
+        data, code = read('nonexistent_user')
+        self.assertEqual(code, 404)
+        self.assertEqual(data, 'File not found')
+
+    def test_read_after_write_overwrite(self):
+        """Test overwriting existing data"""
+        # Write initial data
+        write({'initial': 'data'}, self.test_user_id)
+
+        # Overwrite with new data
+        new_data = {'updated': 'data', 'version': 2}
+        write(new_data, self.test_user_id)
+
+        # Read should return new data
+        data, code = read(self.test_user_id)
+        self.assertEqual(code, 200)
+        self.assertEqual(data, new_data)
+
+    def test_multiple_users_isolation(self):
+        """Test that different users have isolated data"""
+        user1_data = {'user': 'user1', 'value': 100}
+        user2_data = {'user': 'user2', 'value': 200}
+
+        write(user1_data, 'user1')
+        write(user2_data, 'user2')
+
+        data1, code1 = read('user1')
+        data2, code2 = read('user2')
+
+        self.assertEqual(code1, 200)
+        self.assertEqual(code2, 200)
+        self.assertEqual(data1, user1_data)
+        self.assertEqual(data2, user2_data)
+        self.assertNotEqual(data1, data2)
+
+    def test_file_path_construction(self):
+        """Test that files are created in the correct location"""
+        write(self.test_data, self.test_user_id)
+
+        # Check if file exists in temp directory
+        expected_path = os.path.join(self.temp_dir, f"{self.test_user_id}.json")
+        self.assertTrue(os.path.exists(expected_path))
+
+        # Verify file contents
+        with open(expected_path, 'r') as f:
+            file_data = json.load(f)
+        self.assertEqual(file_data, self.test_data)
+
+    def test_write_creates_directory_if_needed(self):
+        """Test that write creates necessary directories"""
+        # This test assumes FILE_STORE_PATH is set to a temp directory
+        # The write function should work even if subdirectories don't exist
+        status, code = write(self.test_data, self.test_user_id)
+        self.assertEqual(status, 'ok')
+        self.assertEqual(code, 200)
+
+    def test_read_file_corruption(self):
+        """Test reading corrupted JSON file"""
+        # Create a corrupted JSON file manually
+        file_path = os.path.join(self.temp_dir, f"{self.test_user_id}.json")
+        with open(file_path, 'w') as f:
+            f.write('{"invalid": json syntax}')
+
+        # This should raise a JSONDecodeError since the file_store doesn't handle corrupted JSON
+        with self.assertRaises(json.JSONDecodeError):
+            read(self.test_user_id)
+
+    def test_environment_variable_file_store_path(self):
+        """Test that FILE_STORE_PATH environment variable is respected"""
+        # With our mocking, files should go to temp_dir
+        write(self.test_data, self.test_user_id)
+        expected_path = os.path.join(self.temp_dir, f"{self.test_user_id}.json")
+
+        # The file should exist in the mocked temp directory
+        self.assertTrue(os.path.exists(expected_path))
+
+        # Clean up
+        if os.path.exists(expected_path):
+            os.remove(expected_path)
 
 if __name__ == '__main__':
     unittest.main()