OrpaonVision/OrpaonVision.SiteApp.Tests/Training/ModelPackageImportActivationTests.cs

using Microsoft.Extensions.Logging;
using Moq;
using OrpaonVision.Core.Results;
using OrpaonVision.Core.Training;
using OrpaonVision.Core.Training.Contracts;
using OrpaonVision.Core.Training.Contracts.Commands;

namespace OrpaonVision.SiteApp.Tests.Training;

/// <summary>
/// 模型包导入激活单元测试。
/// </summary>
[TestClass]
public class ModelPackageImportActivationTests
{
    private Mock<IModelPackageAppService> _modelPackageServiceMock = null!;
    private Mock<ILogger<IModelPackageAppService>> _loggerMock = null!;

    [TestInitialize]
    public void TestInitialize()
    {
        _modelPackageServiceMock = new Mock<IModelPackageAppService>();
        _loggerMock = new Mock<ILogger<IModelPackageAppService>>();
    }

    [TestMethod]
    public async Task ImportPackageAsync_ValidPackage_ReturnsSuccess()
    {
        // Arrange
        var packagePath = "test_package.ovpkg";
        var expectedResult = new ModelPackageImportResultDto
        {
            ModelPackageId = Guid.NewGuid(),
            Status = ModelPackageImportStatus.Imported,
            Message = "导入成功",
            ImportedAtUtc = DateTime.UtcNow,
            ImportedBy = "TestUser"
        };

        _modelPackageServiceMock
            .Setup(x => x.ImportPackageAsync(packagePath, It.IsAny<CancellationToken>()))
            .ReturnsAsync(Result<ModelPackageImportResultDto>.Success(expectedResult));

        // Act
        var result = await _modelPackageServiceMock.Object.ImportPackageAsync(packagePath);

        // Assert
        Assert.IsTrue(result.Succeeded);
        Assert.IsNotNull(result.Data);
        Assert.AreEqual(ModelPackageImportStatus.Imported, result.Data.Status);
        Assert.AreEqual("导入成功", result.Data.Message);
        Assert.AreEqual("TestUser", result.Data.ImportedBy);
    }

    [TestMethod]
    public async Task ImportPackageAsync_InvalidPackage_ReturnsFailure()
    {
        // Arrange
        var packagePath = "invalid_package.ovpkg";
        var expectedError = Result<ModelPackageImportResultDto>.Fail("INVALID_PACKAGE", "模型包格式无效");

        _modelPackageServiceMock
            .Setup(x => x.ImportPackageAsync(packagePath, It.IsAny<CancellationToken>()))
            .ReturnsAsync(expectedError);

        // Act
        var result = await _modelPackageServiceMock.Object.ImportPackageAsync(packagePath);

        // Assert
        Assert.IsFalse(result.Succeeded);
        Assert.AreEqual("INVALID_PACKAGE", result.Code);
        Assert.AreEqual("模型包格式无效", result.Message);
    }

    [TestMethod]
    public async Task ImportPackageAsync_MissingFile_ReturnsFailure()
    {
        // Arrange
        var packagePath = "missing_package.ovpkg";
        var expectedError = Result<ModelPackageImportResultDto>.Fail("FILE_NOT_FOUND", "模型包文件不存在");

        _modelPackageServiceMock
            .Setup(x => x.ImportPackageAsync(packagePath, It.IsAny<CancellationToken>()))
            .ReturnsAsync(expectedError);

        // Act
        var result = await _modelPackageServiceMock.Object.ImportPackageAsync(packagePath);

        // Assert
        Assert.IsFalse(result.Succeeded);
        Assert.AreEqual("FILE_NOT_FOUND", result.Code);
        Assert.AreEqual("模型包文件不存在", result.Message);
    }

    [TestMethod]
    public async Task ActivatePackageAsync_ValidPackage_ReturnsSuccess()
    {
        // Arrange
        var packageId = Guid.NewGuid();
        var expectedResult = new ModelPackageActivationResultDto
        {
            ModelPackageId = packageId,
            Status = ModelPackageActivationStatus.Activated,
            Message = "激活成功",
            ActivatedAtUtc = DateTime.UtcNow,
            ActivatedBy = "TestUser"
        };

        _modelPackageServiceMock
            .Setup(x => x.ActivatePackageAsync(packageId, It.IsAny<CancellationToken>()))
            .ReturnsAsync(Result<ModelPackageActivationResultDto>.Success(expectedResult));

        // Act
        var result = await _modelPackageServiceMock.Object.ActivatePackageAsync(packageId);

        // Assert
        Assert.IsTrue(result.Succeeded);
        Assert.IsNotNull(result.Data);
        Assert.AreEqual(ModelPackageActivationStatus.Activated, result.Data.Status);
        Assert.AreEqual("激活成功", result.Data.Message);
        Assert.AreEqual("TestUser", result.Data.ActivatedBy);
    }

    [TestMethod]
    public async Task ActivatePackageAsync_PackageNotFound_ReturnsFailure()
    {
        // Arrange
        var packageId = Guid.NewGuid();
        var expectedError = Result<ModelPackageActivationResultDto>.Fail("PACKAGE_NOT_FOUND", "模型包不存在");

        _modelPackageServiceMock
            .Setup(x => x.ActivatePackageAsync(packageId, It.IsAny<CancellationToken>()))
            .ReturnsAsync(expectedError);

        // Act
        var result = await _modelPackageServiceMock.Object.ActivatePackageAsync(packageId);

        // Assert
        Assert.IsFalse(result.Succeeded);
        Assert.AreEqual("PACKAGE_NOT_FOUND", result.Code);
        Assert.AreEqual("模型包不存在", result.Message);
    }

    [TestMethod]
    public async Task ActivatePackageAsync_AlreadyActivated_ReturnsFailure()
    {
        // Arrange
        var packageId = Guid.NewGuid();
        var expectedError = Result<ModelPackageActivationResultDto>.Fail("ALREADY_ACTIVATED", "模型包已激活");

        _modelPackageServiceMock
            .Setup(x => x.ActivatePackageAsync(packageId, It.IsAny<CancellationToken>()))
            .ReturnsAsync(expectedError);

        // Act
        var result = await _modelPackageServiceMock.Object.ActivatePackageAsync(packageId);

        // Assert
        Assert.IsFalse(result.Succeeded);
        Assert.AreEqual("ALREADY_ACTIVATED", result.Code);
        Assert.AreEqual("模型包已激活", result.Message);
    }

    [TestMethod]
    public async Task ImportAndActivate_CompleteWorkflow_ReturnsSuccess()
    {
        // Arrange
        var packagePath = "test_package.ovpkg";
        var packageId = Guid.NewGuid();
        
        var importResult = new ModelPackageImportResultDto
        {
            ModelPackageId = packageId,
            Status = ModelPackageImportStatus.Imported,
            Message = "导入成功",
            ImportedAtUtc = DateTime.UtcNow,
            ImportedBy = "TestUser"
        };

        var activationResult = new ModelPackageActivationResultDto
        {
            ModelPackageId = packageId,
            Status = ModelPackageActivationStatus.Activated,
            Message = "激活成功",
            ActivatedAtUtc = DateTime.UtcNow,
            ActivatedBy = "TestUser"
        };

        _modelPackageServiceMock
            .Setup(x => x.ImportPackageAsync(packagePath, It.IsAny<CancellationToken>()))
            .ReturnsAsync(Result<ModelPackageImportResultDto>.Success(importResult));

        _modelPackageServiceMock
            .Setup(x => x.ActivatePackageAsync(packageId, It.IsAny<CancellationToken>()))
            .ReturnsAsync(Result<ModelPackageActivationResultDto>.Success(activationResult));

        // Act - Import
        var importStep = await _modelPackageServiceMock.Object.ImportPackageAsync(packagePath);
        
        // Assert - Import
        Assert.IsTrue(importStep.Succeeded);
        Assert.AreEqual(packageId, importStep.Data.ModelPackageId);

        // Act - Activate
        var activationStep = await _modelPackageServiceMock.Object.ActivatePackageAsync(packageId);

        // Assert - Activate
        Assert.IsTrue(activationStep.Succeeded);
        Assert.AreEqual(packageId, activationStep.Data.ModelPackageId);
        Assert.AreEqual(ModelPackageActivationStatus.Activated, activationStep.Data.Status);
    }

    [TestMethod]
    public async Task ImportAndActivate_ImportFailure_StopsWorkflow()
    {
        // Arrange
        var packagePath = "invalid_package.ovpkg";
        var packageId = Guid.NewGuid();
        
        var importError = Result<ModelPackageImportResultDto>.Fail("INVALID_FORMAT", "模型包格式无效");

        _modelPackageServiceMock
            .Setup(x => x.ImportPackageAsync(packagePath, It.IsAny<CancellationToken>()))
            .ReturnsAsync(importError);

        // Act
        var importStep = await _modelPackageServiceMock.Object.ImportPackageAsync(packagePath);

        // Assert
        Assert.IsFalse(importStep.Succeeded);
        Assert.AreEqual("INVALID_FORMAT", importStep.Code);
        
        // Verify that activation was not attempted
        _modelPackageServiceMock.Verify(
            x => x.ActivatePackageAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()),
            Times.Never);
    }
}