tests/MatControl.Tests/DatabaseBackupServiceTests.cs - master - valzem/MatControl

tests/MatControl.Tests/DatabaseBackupServiceTests.cs

128 строк5 KB

MatControl Dev

Бэкап, восстановление и очистка БД: DatabaseBackupService (SQLite Backup API, восстановление через временную копию, очистка всех записей), кнопки 'Бэкап БД', 'Восстановить БД', 'Очистить БД' внизу панели навигации MainForm, пересоздание разделов после изменений; AGENTS.md, скиллы и tasks.md обновлены (83 теста)

09 авг 2026, 10:52

09 авг 2026, 10:52aef4c5a

using MatControl.Business;
using MatControl.Data;
using MatControl.Domain;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;

namespace MatControl.Tests;

public class DatabaseBackupServiceTests : IDisposable
{
    private readonly string _dbPath;
    private readonly string _backupPath;
    private readonly string _directory;

    public DatabaseBackupServiceTests()
    {
        _directory = Path.Combine(Path.GetTempPath(), $"matcontrol_bak_{Guid.NewGuid():N}");
        Directory.CreateDirectory(_directory);
        _dbPath = Path.Combine(_directory, "test.db");
        _backupPath = Path.Combine(_directory, "backup.db");
    }

    private async Task<MatControlDbContext> CreateContextAsync()
    {
        var options = new DbContextOptionsBuilder<MatControlDbContext>()
            .UseSqlite($"Data Source={_dbPath}")
            .Options;
        var context = new MatControlDbContext(options);
        await DbInitializer.InitializeAsync(context);
        return context;
    }

    [Fact]
    public async Task CreateBackupAsync_CreatesFileWithSameData()
    {
        using var context = await CreateContextAsync();
        context.Employees.Add(new Employee { FullName = "Тест Тест Тестович", IsResponsible = false });
        await context.SaveChangesAsync();
        var service = new DatabaseBackupService(context, _dbPath, NullLogger<DatabaseBackupService>.Instance);

        var result = await service.CreateBackupAsync(_backupPath);

        Assert.True(result.IsSuccess);
        Assert.True(File.Exists(_backupPath));
        Assert.Equal(1, CountEmployees(_backupPath));
    }

    [Fact]
    public async Task RestoreAsync_RestoresOriginalData_WhenDataChanged()
    {
        using var context = await CreateContextAsync();
        context.Employees.Add(new Employee { FullName = "Оригинал Оригиналовна", IsResponsible = false });
        await context.SaveChangesAsync();
        var service = new DatabaseBackupService(context, _dbPath, NullLogger<DatabaseBackupService>.Instance);

        await service.CreateBackupAsync(_backupPath);

        await context.Database.ExecuteSqlRawAsync("DELETE FROM Employees");
        Assert.Equal(0, await context.Employees.CountAsync());

        var restore = await service.RestoreAsync(_backupPath);

        Assert.True(restore.IsSuccess);
        Assert.Equal(1, await context.Employees.CountAsync());
    }

    [Fact]
    public async Task RestoreAsync_ReturnsFail_WhenFileIsNotSqlite()
    {
        using var context = await CreateContextAsync();
        var service = new DatabaseBackupService(context, _dbPath, NullLogger<DatabaseBackupService>.Instance);
        var notSqlite = Path.Combine(_directory, "not_sqlite.db");
        await File.WriteAllTextAsync(notSqlite, "this is not a database");

        var result = await service.RestoreAsync(notSqlite);

        Assert.False(result.IsSuccess);
    }

    [Fact]
    public async Task RestoreAsync_ReturnsFail_WhenFileDoesNotExist()
    {
        using var context = await CreateContextAsync();
        var service = new DatabaseBackupService(context, _dbPath, NullLogger<DatabaseBackupService>.Instance);

        var result = await service.RestoreAsync(Path.Combine(_directory, "missing.db"));

        Assert.False(result.IsSuccess);
    }

    [Fact]
    public async Task ClearDatabaseAsync_RemovesAllRows()
    {
        using var context = await CreateContextAsync();
        context.Employees.Add(new Employee { FullName = "Сотрудник Тестов", IsResponsible = true });
        context.Assets.Add(new Asset { InventoryNumber = "0001", Name = "Ноутбук" });
        context.Supplies.Add(new Supply { Name = "Бумага", Quantity = 10, Price = 20 });
        await context.SaveChangesAsync();
        var service = new DatabaseBackupService(context, _dbPath, NullLogger<DatabaseBackupService>.Instance);

        var result = await service.ClearDatabaseAsync();

        Assert.True(result.IsSuccess);
        Assert.Equal(0, await context.Employees.CountAsync());
        Assert.Equal(0, await context.Assets.CountAsync());
        Assert.Equal(0, await context.Supplies.CountAsync());
        Assert.Equal(0, await context.AssetMovements.CountAsync());
    }

    private static int CountEmployees(string path)
    {
        using var connection = new SqliteConnection($"Data Source={path};Pooling=False");
        connection.Open();
        using var command = connection.CreateCommand();
        command.CommandText = "SELECT COUNT(*) FROM Employees";
        return Convert.ToInt32(command.ExecuteScalar());
    }

    public void Dispose()
    {
        SqliteConnection.ClearAllPools();
        if (Directory.Exists(_directory))
        {
            Directory.Delete(_directory, true);
        }
    }
}