it/backend/HardwarePerformance.Infrastructure.Tests/Repositories/RepositoryTests.cs

using Microsoft.EntityFrameworkCore;
using HardwarePerformance.Core.Entities;
using HardwarePerformance.Infrastructure.Data;
using HardwarePerformance.Infrastructure.Repositories;

namespace HardwarePerformance.Infrastructure.Tests.Repositories
{
    /// <summary>
    /// Repository基类单元测试
    /// </summary>
    public class RepositoryTests : TestBase
    {
        private readonly Repository<Category> _categoryRepository;
        private readonly Repository<Product> _productRepository;

        public RepositoryTests()
        {
            _categoryRepository = new Repository<Category>(_context);
            _productRepository = new Repository<Product>(_context);
        }

        [Fact]
        public async Task GetByIdAsync_WithValidId_ReturnsEntity()
        {
            // Arrange
            var categoryId = 1;

            // Act
            var result = await _categoryRepository.GetByIdAsync(categoryId);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(categoryId, result.Id);
        }

        [Fact]
        public async Task GetByIdAsync_WithInvalidId_ReturnsNull()
        {
            // Arrange
            var categoryId = 999;

            // Act
            var result = await _categoryRepository.GetByIdAsync(categoryId);

            // Assert
            Assert.Null(result);
        }

        [Fact]
        public async Task GetAllAsync_ReturnsAllEntities()
        {
            // Act
            var result = await _categoryRepository.GetAllAsync();

            // Assert
            Assert.NotNull(result);
            Assert.Equal(4, result.Count());
        }

        [Fact]
        public async Task FindAsync_WithValidPredicate_ReturnsFilteredEntities()
        {
            // Arrange
            var predicate = (Category c) => c.Name.Contains("CPU");

            // Act
            var result = await _categoryRepository.FindAsync(predicate);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(2, result.Count());
            Assert.All(result, c => Assert.Contains("CPU", c.Name));
        }

        [Fact]
        public async Task ExistsAsync_WithExistingEntity_ReturnsTrue()
        {
            // Arrange
            var predicate = (Category c) => c.Name == "手机CPU";

            // Act
            var result = await _categoryRepository.ExistsAsync(predicate);

            // Assert
            Assert.True(result);
        }

        [Fact]
        public async Task ExistsAsync_WithNonExistingEntity_ReturnsFalse()
        {
            // Arrange
            var predicate = (Category c) => c.Name == "不存在的类别";

            // Act
            var result = await _categoryRepository.ExistsAsync(predicate);

            // Assert
            Assert.False(result);
        }

        [Fact]
        public async Task AddAsync_WithValidEntity_ReturnsAddedEntity()
        {
            // Arrange
            var newCategory = new Category
            {
                Name = "测试类别",
                Description = "测试类别描述",
                Icon = "test"
            };

            // Act
            var result = await _categoryRepository.AddAsync(newCategory);

            // Assert
            Assert.NotNull(result);
            Assert.True(result.Id > 0);
            Assert.Equal("测试类别", result.Name);

            // 验证是否已添加到数据库
            var savedCategory = await _categoryRepository.GetByIdAsync(result.Id);
            Assert.NotNull(savedCategory);
            Assert.Equal("测试类别", savedCategory.Name);
        }

        [Fact]
        public async Task UpdateAsync_WithValidEntity_ReturnsUpdatedEntity()
        {
            // Arrange
            var category = await _categoryRepository.GetByIdAsync(1);
            category.Description = "更新后的描述";

            // Act
            var result = await _categoryRepository.UpdateAsync(category);

            // Assert
            Assert.NotNull(result);
            Assert.Equal("更新后的描述", result.Description);

            // 验证是否已更新到数据库
            var savedCategory = await _categoryRepository.GetByIdAsync(1);
            Assert.Equal("更新后的描述", savedCategory.Description);
        }

        [Fact]
        public async Task DeleteAsync_WithValidEntity_ReturnsTrue()
        {
            // Arrange
            var category = await _categoryRepository.GetByIdAsync(1);

            // Act
            var result = await _categoryRepository.DeleteAsync(category);

            // Assert
            Assert.True(result);

            // 验证是否已从数据库删除
            var deletedCategory = await _categoryRepository.GetByIdAsync(1);
            Assert.Null(deletedCategory);
        }

        [Fact]
        public async Task DeleteByIdAsync_WithValidId_ReturnsTrue()
        {
            // Arrange
            var categoryId = 1;

            // Act
            var result = await _categoryRepository.DeleteByIdAsync(categoryId);

            // Assert
            Assert.True(result);

            // 验证是否已从数据库删除
            var deletedCategory = await _categoryRepository.GetByIdAsync(categoryId);
            Assert.Null(deletedCategory);
        }

        [Fact]
        public async Task DeleteByIdAsync_WithInvalidId_ReturnsFalse()
        {
            // Arrange
            var categoryId = 999;

            // Act
            var result = await _categoryRepository.DeleteByIdAsync(categoryId);

            // Assert
            Assert.False(result);
        }

        [Fact]
        public async Task CountAsync_ReturnsCorrectCount()
        {
            // Act
            var result = await _categoryRepository.CountAsync();

            // Assert
            Assert.Equal(4, result);
        }

        [Fact]
        public async Task CountAsync_WithPredicate_ReturnsCorrectCount()
        {
            // Arrange
            var predicate = (Category c) => c.Name.Contains("CPU");

            // Act
            var result = await _categoryRepository.CountAsync(predicate);

            // Assert
            Assert.Equal(2, result);
        }

        [Fact]
        public async Task AddRangeAsync_WithValidEntities_ReturnsAddedEntities()
        {
            // Arrange
            var newCategories = new List<Category>
            {
                new Category
                {
                    Name = "测试类别1",
                    Description = "测试类别描述1",
                    Icon = "test1"
                },
                new Category
                {
                    Name = "测试类别2",
                    Description = "测试类别描述2",
                    Icon = "test2"
                }
            };

            // Act
            var result = await _categoryRepository.AddRangeAsync(newCategories);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(2, result.Count());
            Assert.All(result, c => Assert.True(c.Id > 0));

            // 验证是否已添加到数据库
            var savedCategories = await _categoryRepository.FindAsync(c => c.Name.Contains("测试类别"));
            Assert.Equal(2, savedCategories.Count());
        }

        [Fact]
        public async Task UpdateRangeAsync_WithValidEntities_ReturnsUpdatedEntities()
        {
            // Arrange
            var categories = await _categoryRepository.FindAsync(c => c.Name.Contains("CPU"));
            foreach (var category in categories)
            {
                category.Description = "更新后的描述";
            }

            // Act
            var result = await _categoryRepository.UpdateRangeAsync(categories);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(2, result.Count());
            Assert.All(result, c => Assert.Equal("更新后的描述", c.Description));

            // 验证是否已更新到数据库
            var savedCategories = await _categoryRepository.FindAsync(c => c.Name.Contains("CPU"));
            Assert.All(savedCategories, c => Assert.Equal("更新后的描述", c.Description));
        }

        [Fact]
        public async Task DeleteRangeAsync_WithValidEntities_ReturnsTrue()
        {
            // Arrange
            var categories = await _categoryRepository.FindAsync(c => c.Name.Contains("CPU"));

            // Act
            var result = await _categoryRepository.DeleteRangeAsync(categories);

            // Assert
            Assert.True(result);

            // 验证是否已从数据库删除
            var deletedCategories = await _categoryRepository.FindAsync(c => c.Name.Contains("CPU"));
            Assert.Empty(deletedCategories);
        }

        [Fact]
        public async Task FirstOrDefaultAsync_WithValidPredicate_ReturnsEntity()
        {
            // Arrange
            var predicate = (Category c) => c.Name.Contains("CPU");

            // Act
            var result = await _categoryRepository.FirstOrDefaultAsync(predicate);

            // Assert
            Assert.NotNull(result);
            Assert.Contains("CPU", result.Name);
        }

        [Fact]
        public async Task FirstOrDefaultAsync_WithInvalidPredicate_ReturnsNull()
        {
            // Arrange
            var predicate = (Category c) => c.Name == "不存在的类别";

            // Act
            var result = await _categoryRepository.FirstOrDefaultAsync(predicate);

            // Assert
            Assert.Null(result);
        }

        [Fact]
        public async Task LastOrDefaultAsync_WithValidPredicate_ReturnsEntity()
        {
            // Arrange
            var predicate = (Category c) => c.Name.Contains("CPU");

            // Act
            var result = await _categoryRepository.LastOrDefaultAsync(predicate);

            // Assert
            Assert.NotNull(result);
            Assert.Contains("CPU", result.Name);
        }

        [Fact]
        public async Task LastOrDefaultAsync_WithInvalidPredicate_ReturnsNull()
        {
            // Arrange
            var predicate = (Category c) => c.Name == "不存在的类别";

            // Act
            var result = await _categoryRepository.LastOrDefaultAsync(predicate);

            // Assert
            Assert.Null(result);
        }

        [Fact]
        public async Task AnyAsync_WithValidPredicate_ReturnsTrue()
        {
            // Arrange
            var predicate = (Category c) => c.Name.Contains("CPU");

            // Act
            var result = await _categoryRepository.AnyAsync(predicate);

            // Assert
            Assert.True(result);
        }

        [Fact]
        public async Task AnyAsync_WithInvalidPredicate_ReturnsFalse()
        {
            // Arrange
            var predicate = (Category c) => c.Name == "不存在的类别";

            // Act
            var result = await _categoryRepository.AnyAsync(predicate);

            // Assert
            Assert.False(result);
        }

        [Fact]
        public async Task AllAsync_WithValidPredicate_ReturnsTrue()
        {
            // Arrange
            var predicate = (Category c) => !string.IsNullOrEmpty(c.Name);

            // Act
            var result = await _categoryRepository.AllAsync(predicate);

            // Assert
            Assert.True(result);
        }

        [Fact]
        public async Task AllAsync_WithInvalidPredicate_ReturnsFalse()
        {
            // Arrange
            var predicate = (Category c) => c.Name == "手机CPU";

            // Act
            var result = await _categoryRepository.AllAsync(predicate);

            // Assert
            Assert.False(result);
        }
    }
}