copywriting_production/tests/test_template.py

import pytest
import pytest_asyncio
import asyncio
from src.models.template_model import Template, TemplateType
from src.manager.template_manager import TemplateManager, TemplateService
from src.manager.core.db_mongo import BaseMongoManager
from bson import json_util
import json
from utils.logu import get_logger

logger = get_logger('test', console_level='DEBUG')

@pytest.fixture(scope="module")
def event_loop():
    """Create an instance of the default event loop for each test case."""
    loop = asyncio.get_event_loop_policy().new_event_loop()
    yield loop
    loop.close()

@pytest_asyncio.fixture(scope="module")
async def template_manager(event_loop):
    # 确保在同一个事件循环中执行
    logger.info("Initializing template manager...")
    manager = TemplateManager()
    await manager.initialize()
    try:
        yield manager
    finally:
        # 清理测试数据
        logger.info("Cleaning up test data...")
        await Template.find().delete()

@pytest.mark.asyncio
async def test_template_crud(template_manager):
    logger.info("Running test_template_crud...")
    
    # 测试创建模板
    logger.debug("Creating template...")
    template = await template_manager.create_template(
        name="test_agg",
        template_str=json.dumps([{"$match": {"name": "{{product_name}}"}}]),
        template_type=TemplateType.AGGREGATION,
        description="测试聚合模板"
    )
    logger.info(f"Created template: {template}")
    assert template.name == "test_agg"
    
    # 测试获取模板
    logger.debug("Fetching template...")
    fetched = await template_manager.get_template("test_agg")
    logger.info(f"Fetched template: {fetched}")
    assert fetched is not None
    assert fetched.description == "测试聚合模板"
    
    # 测试更新模板
    logger.debug("Updating template...")
    updated = await template_manager.update_template(
        "test_agg",
        new_description="更新后的描述"
    )
    logger.info(f"Updated template: {updated}")
    assert updated.description == "更新后的描述"
    
    # 测试删除模板
    logger.debug("Deleting template...")
    result = await template_manager.delete_template("test_agg")
    logger.info(f"Delete result: {result}")
    assert result is True
    assert await template_manager.get_template("test_agg") is None

@pytest.mark.asyncio
async def test_template_render(template_manager):
    logger.info("Running test_template_render...")
    
    # 创建测试模板
    logger.debug("Creating template for rendering...")
    await template_manager.create_template(
        name="render_test",
        template_str=json.dumps([{"$match": {"name": "{{product_name}}"}}]),
        template_type=TemplateType.AGGREGATION
    )
    
    # 测试渲染
    logger.debug("Rendering template...")
    context = {"product_name": "电线保护套"}
    pipeline = template_manager.render_template(
        '[{"$match": {"name": "{{product_name}}"}}]',
        context
    )
    logger.info(f"Rendered pipeline: {pipeline}")
    assert pipeline == [{"$match": {"name": "电线保护套"}}]

@pytest.mark.asyncio
async def test_template_execute(template_manager):
    logger.info("Running test_template_execute...")
    
    # 创建测试模板
    logger.debug("Creating template for execution...")
    await template_manager.create_template(
        name="exec_test",
        template_str=json.dumps([{"$match": {"basic_info.name": "{{product_name}}"}}]),
        template_type=TemplateType.AGGREGATION
    )
    
    # 测试执行（需要mock数据库或已有测试数据）
    try:
        logger.debug("Executing template...")
        result = await template_manager.execute_template(
            "exec_test",
            {"product_name": "电线保护套"}
        )
        logger.info(f"Execution result: {result}")
        assert isinstance(result, list)
    except Exception as e:
        logger.warning(f"Skipping test due to missing MongoDB or test data: {e}")
        pytest.skip(f"需要有效的MongoDB连接或测试数据: {e}")

@pytest.mark.asyncio
async def test_template_service():
    logger.info("Running test_template_service...")
    
    # 测试服务单例
    logger.debug("Getting TemplateService instance...")
    service1 = await TemplateService.get_instance()
    service2 = await TemplateService.get_instance()
    logger.info(f"Service1: {service1}, Service2: {service2}")
    assert service1 is service2