JWT аутентификация в ASP.NET Core

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)

public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = Configuration["Jwt:Issuer"],
            ValidAudience = Configuration["Jwt:Issuer"],
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(Configuration["Jwt:Key"]))
        };
    });
    
    services.AddControllers();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Другие middleware
    
    app.UseAuthentication();
    app.UseAuthorization();
    
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

[Route("api/[controller]")]
[ApiController]
public class AuthController : ControllerBase
{
    private readonly IConfiguration _config;
    
    public AuthController(IConfiguration config)
    {
        _config = config;
    }
    
    [HttpPost("login")]
    [AllowAnonymous]
    public IActionResult Login([FromBody] LoginModel login)
    {
        var user = AuthenticateUser(login);
        
        if (user != null)
        {
            var token = GenerateJWT(user);
            return Ok(new { token });
        }
        
        return Unauthorized();
    }
    
    private string GenerateJWT(UserModel user)
    {
        var securityKey = new SymmetricSecurityKey(
            Encoding.UTF8.GetBytes(_config["Jwt:Key"]));
        var credentials = new SigningCredentials(
            securityKey, SecurityAlgorithms.HmacSha256);
            
        var claims = new[]
        {
            new Claim(JwtRegisteredClaimNames.Sub, user.Username),
            new Claim(JwtRegisteredClaimNames.Email, user.Email),
            new Claim("role", user.Role),
            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
        };
        
        var token = new JwtSecurityToken(
            issuer: _config["Jwt:Issuer"],
            audience: _config["Jwt:Issuer"],
            claims: claims,
            expires: DateTime.Now.AddMinutes(30),
            signingCredentials: credentials
        );
        
        return new JwtSecurityTokenHandler().WriteToken(token);
    }
    
    // Метод аутентификации пользователя 
    // (в реальном приложении здесь будет проверка в БД)
    private UserModel AuthenticateUser(LoginModel login)
    {
        // Демо-имплементация для примера
        if (login.Username == "admin" && login.Password == "password")
        {
            return new UserModel 
            { 
                Username = "admin", 
                Email = "admin@example.com", 
                Role = "Administrator" 
            };
        }
        return null;
    }
}

[Route("api/[controller]")]
[ApiController]
[Authorize] // Весь контроллер требует аутентификации
public class ValuesController : ControllerBase
{
    [HttpGet]
    public IActionResult Get()
    {
        return Ok(new string[] { "value1", "value2" });
    }
    
    [HttpGet("{id}")]
    [AllowAnonymous] // Этот метод доступен без аутентификации
    public IActionResult Get(int id)
    {
        return Ok($"value{id}");
    }
}

[HttpGet("profile")]
[Authorize]
public IActionResult GetProfile()
{
    var username = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
    var email = User.FindFirst(ClaimTypes.Email)?.Value;
    
    return Ok(new { username, email });
}

var claims = new List<Claim>
{
    new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
    new Claim(JwtRegisteredClaimNames.Email, user.Email),
    new Claim(ClaimTypes.Name, user.Username),
    new Claim("DateOfJoining", user.JoinDate.ToString("yyyy-MM-dd")),
    new Claim("Department", user.Department)
};
 
// Добавление ролей пользователя как отдельных claims
foreach (var role in user.Roles)
{
    claims.Add(new Claim(ClaimTypes.Role, role));
}

[HttpGet("admin-data")]
[Authorize(Roles = "Administrator")]
public IActionResult GetAdminData()
{
    return Ok(new { message = "Это секретные данные для администраторов" });
}
 
[HttpGet("multi-role")]
[Authorize(Roles = "Administrator,Manager")]
public IActionResult GetMultiRoleData()
{
    return Ok(new { message = "Доступно администраторам и менеджерам" });
}

// В ConfigureServices
services.AddAuthorization(options =>
{
    options.AddPolicy("SeniorHR", policy =>
        policy.RequireRole("HR")
              .RequireClaim("Department", "HumanResources")
              .RequireAssertion(context =>
                  DateTime.Parse(context.User.FindFirstValue("DateOfJoining")) < 
                  DateTime.Now.AddYears(-5)));
});
 
// В контроллере
[HttpGet("senior-hr-data")]
[Authorize(Policy = "SeniorHR")]
public IActionResult GetSeniorHRData()
{
    return Ok(new { message = "Данные для опытных HR-специалистов" });
}

services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(/* настройки JWT */)
.AddGoogle(options =>
{
    options.ClientId = Configuration["Authentication:Google:ClientId"];
    options.ClientSecret = Configuration["Authentication:Google:ClientSecret"];
    options.CallbackPath = "/signin-google";
})
.AddFacebook(options =>
{
    options.AppId = Configuration["Authentication:Facebook:AppId"];
    options.AppSecret = Configuration["Authentication:Facebook:AppSecret"];
    options.CallbackPath = "/signin-facebook";
});

[Route("auth/[action]")]
public async Task<IActionResult> ExternalLoginCallback()
{
    var info = await HttpContext.AuthenticateAsync(IdentityConstants.ExternalScheme);
    if (!info.Succeeded) return Unauthorized();
    
    var email = info.Principal.FindFirstValue(ClaimTypes.Email);
    // Поиск или создание пользователя по email
    var user = await _userService.FindOrCreateFromExternalLoginAsync(
        email, 
        info.Principal.FindFirstValue(ClaimTypes.Name),
        info.LoginProvider);
    
    // Генерация JWT
    var token = GenerateJWT(user);
    
    // Возврат токена или редирект на клиентское приложение с токеном
    return Ok(new { token });
}

[HttpPost("validate-2fa")]
[Authorize]
public async Task<IActionResult> ValidateTwoFactorCode([FromBody] TwoFactorModel model)
{
    var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
    var user = await _userManager.FindByIdAsync(userId);
    
    var isValid = await _userManager.VerifyTwoFactorTokenAsync(
        user, 
        _userManager.Options.Tokens.AuthenticatorTokenProvider, 
        model.Code);
    
    if (!isValid) return BadRequest("Неверный код");
    
    // Выдача специального JWT с повышенными правами
    var elevatedToken = GenerateElevatedJWT(user);
    
    return Ok(new { token = elevatedToken });
}

services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        // Другие параметры...
        
        // Защита от JWT bombing
        options.TokenValidationParameters.MaximumTokenSizeInBytes = 8192; // 8 KB
    });

[HttpPost("refresh")]
public async Task<IActionResult> RefreshToken([FromBody] RefreshTokenRequest request)
{
    var refreshToken = await _tokenService.FindRefreshTokenAsync(request.RefreshToken);
    
    if (refreshToken == null || refreshToken.IsRevoked || refreshToken.ExpiryDate < DateTime.UtcNow)
    {
        return Unauthorized("Недействительный refresh-токен");
    }
    
    var user = await _userService.GetByIdAsync(refreshToken.UserId);
    if (user == null)
    {
        return Unauthorized("Пользователь не найден");
    }
    
    // Генерация нового access-токена
    var newAccessToken = GenerateJWT(user);
    
    // Опционально: ротация refresh-токена для повышения безопасности
    var newRefreshToken = GenerateRefreshToken();
    await _tokenService.RevokeAndReplaceRefreshTokenAsync(refreshToken.Id, newRefreshToken);
    
    return Ok(new 
    {
        accessToken = newAccessToken,
        refreshToken = newRefreshToken.Token
    });
}

public class CachedTokenValidator : ISecurityTokenValidator
{
    private readonly JwtSecurityTokenHandler _innerValidator = new JwtSecurityTokenHandler();
    private readonly IMemoryCache _cache;
    
    public CachedTokenValidator(IMemoryCache cache)
    {
        _cache = cache;
    }
    
    public bool ValidateToken(string token, TokenValidationParameters parameters, out SecurityToken validatedToken)
    {
        var cacheKey = $"Token_{ComputeHash(token)}";
        
        if (_cache.TryGetValue(cacheKey, out var cachedResult))
        {
            validatedToken = (SecurityToken)cachedResult;
            return true;
        }
        
        var isValid = _innerValidator.ValidateToken(token, parameters, out validatedToken);
        
        if (isValid)
        {
            _cache.Set(cacheKey, validatedToken, TimeSpan.FromMinutes(5));
        }
        
        return isValid;
    }
    
    // Остальные методы интерфейса...
}

options.Events = new JwtBearerEvents
{
    OnAuthenticationFailed = context =>
    {
        if (context.Exception is SecurityTokenExpiredException)
        {
            context.Response.Headers.Add("Token-Expired", "true");
            context.Response.StatusCode = 401;
            context.Response.ContentType = "application/json";
            
            var result = JsonSerializer.Serialize(new { error = "Токен истек" });
            return context.Response.WriteAsync(result);
        }
        else if (context.Exception is SecurityTokenInvalidSignatureException)
        {
            context.Response.StatusCode = 401;
            context.Response.ContentType = "application/json";
            
            var result = JsonSerializer.Serialize(new { error = "Недействительная подпись токена" });
            return context.Response.WriteAsync(result);
        }
        
        return Task.CompletedTask;
    }
};

options.TokenValidationParameters = new TokenValidationParameters
{
    // Другие параметры...
    
    // Добавляем 5 минут запаса для компенсации рассинхронизации часов
    ClockSkew = TimeSpan.FromMinutes(5)
};

options.Events = new JwtBearerEvents
{
    // Другие обработчики...
    
    OnTokenValidated = context =>
    {
        _logger.LogInformation("Успешная валидация токена: {Subject}", 
            context.Principal.FindFirstValue(ClaimTypes.NameIdentifier));
        return Task.CompletedTask;
    },
    
    OnChallenge = context =>
    {
        _logger.LogWarning("Запрос к защищенному ресурсу отклонен: {Resource}", 
            context.Request.Path);
        return Task.CompletedTask;
    }
};

public class AuthenticationTestFixture
{
    private readonly TestServer _server;
    public HttpClient Client { get; }
 
    public AuthenticationTestFixture()
    {
        var builder = new WebHostBuilder()
            .UseStartup<TestStartup>()  // Специальная конфигурация для тестов
            .ConfigureTestServices(services =>
            {
                // Заменяем реальную аутентификацию на тестовую
                services.AddAuthentication("Test")
                    .AddScheme<AuthenticationSchemeOptions, TestAuthHandler>(
                        "Test", options => { });
            });
 
        _server = new TestServer(builder);
        Client = _server.CreateClient();
        
        // Автоматически добавляем заголовок аутентификации ко всем запросам
        Client.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Test", "TestToken");
    }
}
 
// Тестовый обработчик аутентификации
public class TestAuthHandler : AuthenticationHandler<AuthenticationSchemeOptions>
{
    public TestAuthHandler(IOptionsMonitor<AuthenticationSchemeOptions> options,
        ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
        : base(options, logger, encoder, clock)
    {
    }
 
    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        // Создаем тестовые claims для имитации аутентифицированного пользователя
        var claims = new[] {
            new Claim(ClaimTypes.Name, "TestUser"),
            new Claim(ClaimTypes.NameIdentifier, "123"),
            new Claim(ClaimTypes.Role, "Admin")
        };
        var identity = new ClaimsIdentity(claims, "Test");
        var principal = new ClaimsPrincipal(identity);
        var ticket = new AuthenticationTicket(principal, "Test");
 
        return Task.FromResult(AuthenticateResult.Success(ticket));
    }
}

public class RefreshToken
{
    public Guid Id { get; set; }
    public string Token { get; set; }
    public Guid UserId { get; set; }
    public string DeviceId { get; set; }
    public string DeviceName { get; set; }
    public string IpAddress { get; set; }
    public DateTime IssuedAt { get; set; }
    public DateTime ExpiryDate { get; set; }
    public bool IsRevoked { get; set; }
    public string ReplacedByToken { get; set; }
}

services.AddCors(options =>
{
    options.AddPolicy("AllowMyFrontend", builder =>
    {
        builder.WithOrigins("https://myfrontend.com")
               .AllowAnyMethod()
               .AllowAnyHeader()
               .AllowCredentials();
    });
});
 
// И не забудьте применить политику в методе Configure
app.UseCors("AllowMyFrontend");

JWTAuthDemo/
├── JWTAuthDemo.API             # API проект с контроллерами
├── JWTAuthDemo.Core            # Доменная модель и бизнес-логика
├── JWTAuthDemo.Infrastructure  # Реализации репозиториев, сервисов
└── JWTAuthDemo.Tests           # Тесты

// Пример агрегата в Core проекте
public class User : AggregateRoot
{
    public string Email { get; private set; }
    public string PasswordHash { get; private set; }
    public IReadOnlyList<UserRole> Roles => _roles.AsReadOnly();
    
    private List<UserRole> _roles = new List<UserRole>();
    private List<RefreshToken> _refreshTokens = new List<RefreshToken>();
    
    // Бизнес-методы
    public void AddRefreshToken(RefreshToken token)
    {
        // Логика добавления, включая проверки
        _refreshTokens.Add(token);
    }
    
    public void RevokeAllTokens()
    {
        foreach (var token in _refreshTokens.Where(t => !t.IsRevoked))
        {
            token.Revoke();
        }
    }
    
    // И другие методы...
}

public class AppDbContext : IdentityDbContext<ApplicationUser>
{
    public DbSet<RefreshToken> RefreshTokens { get; set; }
    
    public AppDbContext(DbContextOptions<AppDbContext> options) 
        : base(options) { }
    
    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);
        
        // Конфигурация для RefreshToken
        builder.Entity<RefreshToken>(b =>
        {
            b.HasKey(t => t.Id);
            b.Property(t => t.Token).IsRequired();
            b.Property(t => t.ExpiryDate).IsRequired();
            
            // Связь с пользователем
            b.HasOne<ApplicationUser>()
             .WithMany()
             .HasForeignKey(t => t.UserId)
             .IsRequired()
             .OnDelete(DeleteBehavior.Cascade);
        });
    }
}

public class ApplicationUser : IdentityUser
{
    // Дополнительные поля
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime RegistrationDate { get; set; }
    
    // Навигационное свойство для refresh токенов
    public virtual ICollection<RefreshToken> RefreshTokens { get; set; }
}

public class TokenRefreshMiddleware
{
    private readonly RequestDelegate _next;
    
    public TokenRefreshMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    
    public async Task InvokeAsync(HttpContext context, ITokenService tokenService)
    {
        // Пробуем выполнить обычный запрос
        await _next(context);
        
        // Если получили 401 и есть refresh токен в cookie
        if (context.Response.StatusCode == 401 && 
            context.Request.Cookies.TryGetValue("refresh_token", out var refreshToken))
        {
            try
            {
                // Проверяем refresh токен и выдаем новую пару токенов
                var result = await tokenService.RefreshTokensAsync(refreshToken);
                
                if (result.Success)
                {
                    // Устанавливаем новые токены в cookie
                    context.Response.Cookies.Append("access_token", 
                        result.AccessToken, 
                        new CookieOptions { HttpOnly = true, SameSite = SameSiteMode.Strict });
                    
                    context.Response.Cookies.Append("refresh_token", 
                        result.RefreshToken, 
                        new CookieOptions { HttpOnly = true, SameSite = SameSiteMode.Strict });
                    
                    // Повторяем оригинальный запрос
                    var originalRequest = context.Request.Path;
                    context.Response.StatusCode = 200;
                    await context.Response.WriteAsync($"{{\"redirectUrl\": \"{originalRequest}\"}}");
                }
            }
            catch
            {
                // В случае ошибки оставляем 401
            }
        }
    }
}

app.UseMiddleware<TokenRefreshMiddleware>();

public interface ITokenService
{
    Task<TokenResult> GenerateTokensAsync(string userId);
    Task<TokenResult> RefreshTokensAsync(string refreshToken);
    Task RevokeTokenAsync(string refreshToken);
}
 
public class TokenService : ITokenService
{
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly IOptions<JwtSettings> _jwtSettings;
    private readonly AppDbContext _dbContext;
    
    // Конструктор с DI
    
    public async Task<TokenResult> GenerateTokensAsync(string userId)
    {
        var user = await _userManager.FindByIdAsync(userId);
        if (user == null) throw new ArgumentException("Пользователь не найден");
        
        var claims = await GetUserClaimsAsync(user);
        var accessToken = GenerateAccessToken(claims);
        var refreshToken = GenerateRefreshToken();
        
        // Сохраняем refresh токен в БД
        user.RefreshTokens.Add(new RefreshToken
        {
            Token = refreshToken,
            ExpiryDate = DateTime.UtcNow.AddDays(7),
            Created = DateTime.UtcNow,
            CreatedByIp = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress.ToString()
        });
        
        await _dbContext.SaveChangesAsync();
        
        return new TokenResult
        {
            AccessToken = accessToken,
            RefreshToken = refreshToken,
            Success = true
        };
    }
    
    // Остальные методы...
}

// Регистрация сервисов
services.AddDbContext<AppDbContext>(options => 
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
 
services.AddIdentity<ApplicationUser, IdentityRole>()
    .AddEntityFrameworkStores<AppDbContext>()
    .AddDefaultTokenProviders();
 
// JWT настройки
services.Configure<JwtSettings>(Configuration.GetSection("JwtSettings"));
services.AddScoped<ITokenService, TokenService>();
 
// Настройка аутентификации
services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options => 
{
    // Настройки JWT Bearer из предыдущих глав
});

[Route("api/[controller]")]
[ApiController]
public class AuthController : ControllerBase
{
    private readonly ITokenService _tokenService;
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly SignInManager<ApplicationUser> _signInManager;
    private readonly ILogger<AuthController> _logger;
 
    // Конструктор с инъекцией зависимостей
    public AuthController(ITokenService tokenService, 
                         UserManager<ApplicationUser> userManager,
                         SignInManager<ApplicationUser> signInManager,
                         ILogger<AuthController> logger)
    {
        _tokenService = tokenService;
        _userManager = userManager;
        _signInManager = signInManager;
        _logger = logger;
    }
 
    [HttpPost("register")]
    public async Task<IActionResult> Register([FromBody] RegisterModel model)
    {
        if (!ModelState.IsValid)
            return BadRequest(ModelState);
 
        var user = new ApplicationUser
        {
            UserName = model.Email,
            Email = model.Email,
            FirstName = model.FirstName,
            LastName = model.LastName,
            RegistrationDate = DateTime.UtcNow
        };
 
        var result = await _userManager.CreateAsync(user, model.Password);
        
        if (!result.Succeeded)
            return BadRequest(result.Errors);
 
        // Добавление пользователя к роли по умолчанию
        await _userManager.AddToRoleAsync(user, "User");
 
        _logger.LogInformation("Пользователь {Email} зарегистрирован", model.Email);
        
        // Автоматический вход после регистрации
        return await Login(new LoginModel { Email = model.Email, Password = model.Password });
    }
 
    [HttpPost("login")]
    public async Task<IActionResult> Login([FromBody] LoginModel model)
    {
        var user = await _userManager.FindByEmailAsync(model.Email);
        if (user == null)
            return Unauthorized(new { message = "Неверный email или пароль" });
 
        var result = await _signInManager.CheckPasswordSignInAsync(user, model.Password, lockoutOnFailure: true);
        
        if (result.IsLockedOut)
            return BadRequest(new { message = "Аккаунт заблокирован. Попробуйте позже." });
            
        if (!result.Succeeded)
            return Unauthorized(new { message = "Неверный email или пароль" });
 
        var tokenResult = await _tokenService.GenerateTokensAsync(user.Id);
        
        // Сохраняем токены в httpOnly куках для повышения безопасности
        SetTokenCookies(tokenResult);
        
        _logger.LogInformation("Пользователь {Email} вошел в систему", model.Email);
        
        return Ok(new
        {
            userId = user.Id,
            email = user.Email,
            firstName = user.FirstName,
            lastName = user.LastName,
            // Не возвращаем токены в ответе, они уже в куках
        });
    }
 
    [HttpPost("refresh")]
    public async Task<IActionResult> Refresh()
    {
        // Получаем refresh токен из куки
        if (!Request.Cookies.TryGetValue("refresh_token", out var refreshToken))
            return Unauthorized(new { message = "Refresh токен отсутствует" });
            
        try
        {
            var tokenResult = await _tokenService.RefreshTokensAsync(refreshToken);
            
            if (!tokenResult.Success)
                return Unauthorized(new { message = "Невалидный refresh токен" });
                
            SetTokenCookies(tokenResult);
            
            return Ok(new { message = "Токены успешно обновлены" });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при обновлении токенов");
            return Unauthorized(new { message = "Ошибка при обновлении токенов" });
        }
    }
 
    [HttpPost("logout")]
    [Authorize]
    public async Task<IActionResult> Logout()
    {
        // Получаем refresh токен из куки
        if (Request.Cookies.TryGetValue("refresh_token", out var refreshToken))
        {
            await _tokenService.RevokeTokenAsync(refreshToken);
        }
        
        // Удаляем куки
        Response.Cookies.Delete("access_token");
        Response.Cookies.Delete("refresh_token");
        
        return Ok(new { message = "Вы успешно вышли из системы" });
    }
 
    [HttpGet("user")]
    [Authorize]
    public async Task<IActionResult> GetCurrentUser()
    {
        var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        if (string.IsNullOrEmpty(userId))
            return Unauthorized();
            
        var user = await _userManager.FindByIdAsync(userId);
        if (user == null)
            return NotFound(new { message = "Пользователь не найден" });
            
        var roles = await _userManager.GetRolesAsync(user);
        
        return Ok(new
        {
            id = user.Id,
            email = user.Email,
            firstName = user.FirstName,
            lastName = user.LastName,
            roles = roles
        });
    }
 
    private void SetTokenCookies(TokenResult tokens)
    {
        // Настройки для защищенных куков
        var cookieOptions = new CookieOptions
        {
            HttpOnly = true,
            Secure = true, // Для HTTPS
            SameSite = SameSiteMode.Strict,
            Expires = DateTime.UtcNow.AddDays(7)
        };
        
        Response.Cookies.Append("access_token", tokens.AccessToken, cookieOptions);
        Response.Cookies.Append("refresh_token", tokens.RefreshToken, cookieOptions);
    }
}

public class AuthControllerTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly WebApplicationFactory<Program> _factory;
    private readonly HttpClient _client;
 
    public AuthControllerTests(WebApplicationFactory<Program> factory)
    {
        _factory = factory.WithWebHostBuilder(builder =>
        {
            builder.ConfigureServices(services =>
            {
                // Заменяем реальную БД на тестовую в памяти
                var descriptor = services.SingleOrDefault(
                    d => d.ServiceType == typeof(DbContextOptions<AppDbContext>));
                    
                if (descriptor != null)
                    services.Remove(descriptor);
                    
                services.AddDbContext<AppDbContext>(options =>
                    options.UseInMemoryDatabase("TestAuthDb"));
                    
                // Инициализация тестовых данных
                using var scope = services.BuildServiceProvider().CreateScope();
                var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
                var userManager = scope.ServiceProvider.GetRequiredService<UserManager<ApplicationUser>>();
                
                SeedTestData(db, userManager).Wait();
            });
        });
        
        _client = _factory.CreateClient();
    }
 
    [Fact]
    public async Task Login_WithValidCredentials_ReturnsOkAndSetsCookies()
    {
        // Arrange
        var loginModel = new
        {
            Email = "test@example.com",
            Password = "Test123!"
        };
        
        // Act
        var response = await _client.PostAsJsonAsync("/api/auth/login", loginModel);
        
        // Assert
        response.EnsureSuccessStatusCode();
        
        // Проверяем наличие куков
        Assert.True(response.Headers.TryGetValues("Set-Cookie", out var cookies));
        Assert.Contains(cookies, c => c.StartsWith("access_token"));
        Assert.Contains(cookies, c => c.StartsWith("refresh_token"));
        
        // Проверяем содержимое ответа
        var content = await response.Content.ReadFromJsonAsync<dynamic>();
        Assert.Equal("test@example.com", (string)content.email);
    }
 
    private static async Task SeedTestData(AppDbContext db, UserManager<ApplicationUser> userManager)
    {
        db.Database.EnsureCreated();
        
        if (!await db.Users.AnyAsync())
        {
            var user = new ApplicationUser
            {
                UserName = "test@example.com",
                Email = "test@example.com",
                FirstName = "Test",
                LastName = "User",
                EmailConfirmed = true
            };
            
            await userManager.CreateAsync(user, "Test123!");
            await userManager.AddToRoleAsync(user, "User");
        }
    }
}