初始化

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

@@ -0,0 +1,394 @@
+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);
+        }
+    }
+}