diff --git "a/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/PromoCodeFactory.UnitTests.csproj" "b/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/PromoCodeFactory.UnitTests.csproj"
index 3e205e938..59a2e3622 100644
--- "a/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/PromoCodeFactory.UnitTests.csproj"	
+++ "b/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/PromoCodeFactory.UnitTests.csproj"	
@@ -14,10 +14,14 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
     <PackageReference Include="Moq" Version="4.20.72" />
     <PackageReference Include="Soenneker.Utils.AutoBogus" Version="4.0.859" />
-    <PackageReference Include="xunit.v3" Version="3.2.2" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
diff --git "a/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/WebHost/Controllers/Partners/SetLimitTests.cs" "b/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/WebHost/Controllers/Partners/SetLimitTests.cs"
index c84e0d8ac..f6b25bf61 100644
--- "a/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/WebHost/Controllers/Partners/SetLimitTests.cs"	
+++ "b/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/WebHost/Controllers/Partners/SetLimitTests.cs"	
@@ -1,29 +1,201 @@
+using AwesomeAssertions;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using PromoCodeFactory.Core.Abstractions.Repositories;
+using PromoCodeFactory.Core.Domain.Administration;
+using PromoCodeFactory.Core.Domain.PromoCodeManagement;
+using PromoCodeFactory.Core.Exceptions;
+using PromoCodeFactory.WebHost.Controllers;
+using PromoCodeFactory.WebHost.Models.Partners;
+using Soenneker.Utils.AutoBogus;
+
 namespace PromoCodeFactory.UnitTests.WebHost.Controllers.Partners;
 
 public class SetLimitTests
 {
+    private readonly Mock<IRepository<Partner>> _partnersRepositoryMock;
+    private readonly Mock<IRepository<PartnerPromoCodeLimit>> _partnerLimitsRepositoryMock;
+    private readonly PartnersController _partnersController;
+
+    public SetLimitTests()
+    {
+        _partnersRepositoryMock = new Mock<IRepository<Partner>>();
+        _partnerLimitsRepositoryMock = new Mock<IRepository<PartnerPromoCodeLimit>>();
+
+        _partnersController = new PartnersController(_partnersRepositoryMock.Object, _partnerLimitsRepositoryMock.Object);
+    }
+
     [Fact]
     public async Task CreateLimit_WhenPartnerNotFound_ReturnsNotFound()
     {
+        //Arrange
+        var partnerId = Guid.NewGuid();
+        var request = new PartnerPromoCodeLimitCreateRequest(DateTimeOffset.UtcNow.AddDays(1), 100);
+        _partnersRepositoryMock.Setup(x => x.GetById(partnerId, true, It.IsAny<CancellationToken>()))
+            .ReturnsAsync((Partner?)null);
+
+        //Act
+        var result = await _partnersController.CreateLimit(partnerId, request, CancellationToken.None);
+
+        //Assert
+        var notFoundResult = result.Result.Should().BeOfType<NotFoundObjectResult>().Which;
+        notFoundResult.Value.Should().BeOfType<ProblemDetails>();
+        var problemDetails = notFoundResult.Value as ProblemDetails;
+
+        problemDetails!.Title.Should().Be("Partner not found");
+        problemDetails.Detail.Should().Be($"Partner with Id {partnerId} not found.");
     }
 
     [Fact]
     public async Task CreateLimit_WhenPartnerBlocked_ReturnsUnprocessableEntity()
     {
+        //Arrange
+        var partnerId = Guid.NewGuid();
+        var partner = CreatePartner(partnerId, false);
+        var request = new PartnerPromoCodeLimitCreateRequest(DateTimeOffset.UtcNow.AddDays(1), 100);
+        _partnersRepositoryMock.Setup(x => x.GetById(partnerId, true, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(partner);
+
+        //Act
+        var result = await _partnersController.CreateLimit(partnerId, request, CancellationToken.None);
+
+        //Assert
+        var unprocessableResult = result.Result.Should().BeOfType<UnprocessableEntityObjectResult>().Which;
+        unprocessableResult.Value.Should().BeOfType<ProblemDetails>();
+        var problemDetails = unprocessableResult.Value as ProblemDetails;
+
+        problemDetails!.Title.Should().Be("Partner blocked");
+        problemDetails.Detail.Should().Be($"Cannot create limit for a blocked partner.");
     }
 
     [Fact]
     public async Task CreateLimit_WhenValidRequest_ReturnsCreatedAndAddsLimit()
     {
+        //Arrange
+        const int PROMO_CODE_LIMIT = 100;
+
+        var partnerId = Guid.NewGuid();
+        var partner = CreatePartner(partnerId, true);
+        var request = new PartnerPromoCodeLimitCreateRequest(DateTimeOffset.UtcNow.AddDays(1), PROMO_CODE_LIMIT);
+        _partnersRepositoryMock.Setup(x => x.GetById(partnerId, true, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(partner);
+
+        //Act
+        var result = await _partnersController.CreateLimit(partnerId, request, CancellationToken.None);
+
+        //Assert
+        var createdResult = result.Result.Should().BeOfType<CreatedAtActionResult>().Which;
+        createdResult.Value.Should().BeOfType<PartnerPromoCodeLimitResponse>();
+        var response = createdResult.Value as PartnerPromoCodeLimitResponse;
+
+        response!.Limit.Should().Be(100);
+        response.CreatedAt.Should().BeCloseTo(DateTimeOffset.UtcNow, TimeSpan.FromSeconds(5));
+        _partnerLimitsRepositoryMock.Verify(
+            x => x.Add(It.Is<PartnerPromoCodeLimit>(l => l.Limit == PROMO_CODE_LIMIT && l.Partner.Id == partnerId), It.IsAny<CancellationToken>()),
+            Times.Once);
     }
 
     [Fact]
     public async Task CreateLimit_WhenValidRequestWithActiveLimits_CancelsOldLimitsAndAddsNew()
     {
+        //Arrange
+        const int PROMO_CODE_LIMIT = 100;
+
+        var partnerId = Guid.NewGuid();
+        var limitId = Guid.NewGuid();
+        var partner = CreatePartnerWithLimit(partnerId, limitId, isActive: true);
+
+        var request = new PartnerPromoCodeLimitCreateRequest(DateTimeOffset.UtcNow.AddDays(1), PROMO_CODE_LIMIT);
+        _partnersRepositoryMock.Setup(x => x.GetById(partnerId, true, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(partner);
+
+        var oldLimit = partner.PartnerLimits.First();
+
+        //Act
+        var result = await _partnersController.CreateLimit(partnerId, request, CancellationToken.None);
+
+        //Assert
+        var createdResult = result.Result.Should().BeOfType<CreatedAtActionResult>().Which;
+        createdResult.Value.Should().BeOfType<PartnerPromoCodeLimitResponse>();
+        var response = createdResult.Value as PartnerPromoCodeLimitResponse;
+
+        oldLimit.CanceledAt.Should().NotBeNull();
+        var newLimit = result.Value;
+
+        _partnersRepositoryMock.Verify(
+            x => x.Update(It.Is<Partner>(p => p.PartnerLimits.Any(l => l.Id == oldLimit.Id)), It.IsAny<CancellationToken>()),
+            Times.Once);
+        _partnerLimitsRepositoryMock.Verify(
+            x => x.Add(It.Is<PartnerPromoCodeLimit>(l => l.Id == response.Id), It.IsAny<CancellationToken>()),
+            Times.Once);
     }
 
     [Fact]
     public async Task CreateLimit_WhenUpdateThrowsEntityNotFoundException_ReturnsNotFound()
     {
+        //Arrange
+        var partnerId = Guid.NewGuid();
+        var partner = CreatePartnerWithLimit(partnerId, Guid.NewGuid(), isActive: true);
+        var request = new PartnerPromoCodeLimitCreateRequest(DateTimeOffset.UtcNow.AddDays(1), 100);
+        _partnersRepositoryMock.Setup(x => x.GetById(partnerId, true, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(partner);
+        _partnersRepositoryMock.Setup(x => x.Update(It.IsAny<Partner>(), It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new EntityNotFoundException(typeof(Partner), partnerId));
+
+        //Act
+        var result = await _partnersController.CreateLimit(partnerId, request, CancellationToken.None);
+
+        //Assert
+        result.Result.Should().BeOfType<NotFoundResult>();
+    }
+
+    private static Partner CreatePartner(
+        Guid partnerId,
+        bool isActive)
+    {
+        var partner = new AutoFaker<Partner>()
+            .RuleFor(p => p.Id, _ => partnerId)
+            .RuleFor(p => p.IsActive, _ => isActive)
+            .RuleFor(p => p.PartnerLimits, _ => [])
+            .Generate();
+        partner.Manager = new AutoFaker<Employee>().Generate();
+        return partner;
+    }
+
+    private static Partner CreatePartnerWithLimit(
+        Guid partnerId,
+        Guid limitId,
+        bool isActive,
+        DateTimeOffset? canceledAt = null)
+    {
+        var role = new AutoFaker<Role>()
+            .RuleFor(r => r.Id, _ => Guid.NewGuid())
+            .Generate();
+
+        var employee = new AutoFaker<Employee>()
+            .RuleFor(e => e.Id, _ => Guid.NewGuid())
+            .RuleFor(e => e.Role, role)
+            .Generate();
+
+        var limits = new List<PartnerPromoCodeLimit>();
+
+        var partner = new AutoFaker<Partner>()
+            .RuleFor(p => p.Id, _ => partnerId)
+            .RuleFor(p => p.IsActive, _ => isActive)
+            .RuleFor(p => p.Manager, employee)
+            .RuleFor(p => p.PartnerLimits, limits)
+            .Generate();
+
+        var limit = new AutoFaker<PartnerPromoCodeLimit>()
+            .RuleFor(l => l.Id, _ => limitId)
+            .RuleFor(l => l.Partner, partner)
+            .RuleFor(l => l.CanceledAt, _ => canceledAt)
+            .RuleFor(l => l.CreatedAt, _ => DateTimeOffset.UtcNow.AddDays(-1))
+            .RuleFor(l => l.EndAt, _ => DateTimeOffset.UtcNow.AddDays(30))
+            .RuleFor(l => l.Limit, 2)
+            .Generate();
+
+        limits.Add(limit);
+        return partner;
     }
 }
diff --git "a/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/WebHost/Controllers/PromoCodes/CreateTests.cs" "b/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/WebHost/Controllers/PromoCodes/CreateTests.cs"
index 8f66ae5c3..45f01459d 100644
--- "a/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/WebHost/Controllers/PromoCodes/CreateTests.cs"	
+++ "b/Homeworks/04 \320\224\320\276\320\261\320\260\320\262\320\273\320\265\320\275\320\270\320\265 \321\216\320\275\320\270\321\202 \321\202\320\265\321\201\321\202\320\276\320\262/src/PromoCodeFactory.UnitTests/WebHost/Controllers/PromoCodes/CreateTests.cs"	
@@ -1,29 +1,201 @@
+using System.Linq.Expressions;
+using AwesomeAssertions;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using PromoCodeFactory.Core.Abstractions.Repositories;
+using PromoCodeFactory.Core.Domain.Administration;
+using PromoCodeFactory.Core.Domain.PromoCodeManagement;
+using PromoCodeFactory.WebHost.Controllers;
+using PromoCodeFactory.WebHost.Models.PromoCodes;
+using Soenneker.Utils.AutoBogus;
+
 namespace PromoCodeFactory.UnitTests.WebHost.Controllers.PromoCodes;
 
 public class CreateTests
 {
+    private readonly Mock<IRepository<Partner>> _partnersRepositoryMock;
+    private readonly Mock<IRepository<PromoCode>> _promoCodeRepositoryMock;
+    private readonly Mock<IRepository<Customer>> _customerRepositoryMock;
+    private readonly Mock<IRepository<Preference>> _preferenceRepositoryMock;
+    private readonly Mock<IRepository<CustomerPromoCode>> _customerPromoCodeRepositoryMock;
+    private readonly PromoCodesController _promoCodesController;
+
+    public CreateTests()
+    {
+        _partnersRepositoryMock = new Mock<IRepository<Partner>>();
+        _promoCodeRepositoryMock = new Mock<IRepository<PromoCode>>();
+        _customerRepositoryMock = new Mock<IRepository<Customer>>();
+        _preferenceRepositoryMock= new Mock<IRepository<Preference>>();
+        _customerPromoCodeRepositoryMock = new Mock<IRepository<CustomerPromoCode>>();
+
+        _promoCodesController = new PromoCodesController(_promoCodeRepositoryMock.Object, _customerRepositoryMock.Object, _customerPromoCodeRepositoryMock.Object, _partnersRepositoryMock.Object, _preferenceRepositoryMock.Object);
+    }
+
+
     [Fact]
     public async Task Create_WhenPartnerNotFound_ReturnsNotFound()
     {
+        //Arrange
+        var partnerId = Guid.NewGuid();
+        var request = new PromoCodeCreateRequest("Code", "ServiceInfo", partnerId, DateTime.Now, DateTime.Now, new Guid());
+        _partnersRepositoryMock.Setup(x => x.GetById(partnerId, true, It.IsAny<CancellationToken>()))
+            .ReturnsAsync((Partner?)null);
+
+        //Act
+        var result = await _promoCodesController.Create(request, CancellationToken.None);
+
+        //Assert
+        var notFoundResult = result.Result.Should().BeOfType<NotFoundObjectResult>().Which;
+        notFoundResult.Value.Should().BeOfType<ProblemDetails>();
+        var problemDetails = notFoundResult.Value as ProblemDetails;
+
+        problemDetails!.Title.Should().Be("Partner not found");
+        problemDetails.Detail.Should().Be($"Partner with Id {partnerId} not found.");
     }
 
     [Fact]
     public async Task Create_WhenPreferenceNotFound_ReturnsNotFound()
     {
+        //Arrange
+        var partnerId = Guid.NewGuid();
+        var preferenceId = Guid.NewGuid();
+        var partner = CreatePartner(partnerId, true);
+        var request = new PromoCodeCreateRequest("CODE", "ServiceInfo", partnerId, DateTime.UtcNow.AddDays(1), DateTime.UtcNow.AddDays(30), preferenceId);
+        _partnersRepositoryMock.Setup(x => x.GetById(partnerId, true, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(partner);
+        _preferenceRepositoryMock.Setup(x => x.GetById(preferenceId, false, It.IsAny<CancellationToken>()))
+            .ReturnsAsync((Preference?)null);
+
+        //Act
+        var result = await _promoCodesController.Create(request, CancellationToken.None);
+
+        //Assert
+        var notFoundResult = result.Result.Should().BeOfType<NotFoundObjectResult>().Which;
+        notFoundResult.Value.Should().BeOfType<ProblemDetails>();
+        var problemDetails = notFoundResult.Value as ProblemDetails;
+        problemDetails!.Title.Should().Be("Preference not found");
+        problemDetails.Detail.Should().Be($"Preference with Id {preferenceId} not found.");
     }
 
     [Fact]
     public async Task Create_WhenNoActiveLimit_ReturnsUnprocessableEntity()
     {
+        //Arrange
+        var partnerId = Guid.NewGuid();
+        var preferenceId = Guid.NewGuid();
+        var partner = CreatePartner(partnerId, true);
+        var preference = CreatePreference(preferenceId);
+        var request = new PromoCodeCreateRequest("CODE", "ServiceInfo", partnerId, DateTime.UtcNow.AddDays(1), DateTime.UtcNow.AddDays(30), preferenceId);
+        _partnersRepositoryMock.Setup(x => x.GetById(partnerId, true, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(partner);
+        _preferenceRepositoryMock.Setup(x => x.GetById(preferenceId, false, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(preference);
+
+        //Act
+        var result = await _promoCodesController.Create(request, CancellationToken.None);
+
+        //Assert
+        var unprocessableResult = result.Result.Should().BeOfType<ObjectResult>().Which;
+        unprocessableResult.StatusCode.Should().Be(422);
+        unprocessableResult.Value.Should().BeOfType<ProblemDetails>();
+        var problemDetails = unprocessableResult.Value as ProblemDetails;
+        problemDetails!.Title.Should().Be("No active limit");
+        problemDetails.Detail.Should().Be("Partner has no active promo code limit.");
     }
 
     [Fact]
     public async Task Create_WhenLimitExceeded_ReturnsUnprocessableEntity()
     {
+        //Arrange
+        var partnerId = Guid.NewGuid();
+        var preferenceId = Guid.NewGuid();
+        var partner = CreatePartner(partnerId, true, limit: 1, issuedCount: 1);
+        var preference = CreatePreference(preferenceId);
+        var request = new PromoCodeCreateRequest("CODE", "ServiceInfo", partnerId, DateTime.UtcNow.AddDays(1), DateTime.UtcNow.AddDays(30), preferenceId);
+        _partnersRepositoryMock.Setup(x => x.GetById(partnerId, true, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(partner);
+        _preferenceRepositoryMock.Setup(x => x.GetById(preferenceId, false, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(preference);
+
+        //Act
+        var result = await _promoCodesController.Create(request, CancellationToken.None);
+
+        //Assert
+        var unprocessableResult = result.Result.Should().BeOfType<ObjectResult>().Which;
+        unprocessableResult.StatusCode.Should().Be(422);
+        unprocessableResult.Value.Should().BeOfType<ProblemDetails>();
+        var problemDetails = unprocessableResult.Value as ProblemDetails;
+        problemDetails!.Title.Should().Be("Limit exceeded");
+        problemDetails.Detail.Should().Be($"Cannot create promo code. Limit would be exceeded (current: 1/1).");
     }
 
     [Fact]
     public async Task Create_WhenValidRequest_ReturnsCreatedAndIncrementsIssuedCount()
     {
+        //Arrange
+        var partnerId = Guid.NewGuid();
+        var preferenceId = Guid.NewGuid();
+        var partner = CreatePartner(partnerId, true, limit: 100, issuedCount: 0);
+        var preference = CreatePreference(preferenceId);
+        var request = new PromoCodeCreateRequest("CODE", "ServiceInfo", partnerId, DateTime.UtcNow.AddDays(1), DateTime.UtcNow.AddDays(30), preferenceId);
+        _partnersRepositoryMock.Setup(x => x.GetById(partnerId, true, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(partner);
+        _preferenceRepositoryMock.Setup(x => x.GetById(preferenceId, false, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(preference);
+        _customerRepositoryMock.Setup(x => x.GetWhere(It.IsAny<Expression<Func<Customer, bool>>>(), It.IsAny<bool>(), default))
+            .ReturnsAsync(new List<Customer>());
+
+        //Act
+        var result = await _promoCodesController.Create(request, CancellationToken.None);
+
+        //Assert
+        var createdResult = result.Result.Should().BeOfType<CreatedAtActionResult>().Which;
+        createdResult.Value.Should().BeOfType<PromoCodeShortResponse>();
+        var response = createdResult.Value as PromoCodeShortResponse;
+        response!.Code.Should().Be("CODE");
+
+        _promoCodeRepositoryMock.Verify(
+            x => x.Add(It.IsAny<PromoCode>(), It.IsAny<CancellationToken>()),
+            Times.Once);
+        _partnersRepositoryMock.Verify(
+            x => x.Update(It.Is<Partner>(p => p.PartnerLimits.Any(l => l.IssuedCount == 1)), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    private static Partner CreatePartner(
+        Guid partnerId,
+        bool isActive,
+        int limit = 0,
+        int issuedCount = 0)
+    {
+        var partner = new AutoFaker<Partner>()
+            .RuleFor(p => p.Id, _ => partnerId)
+            .RuleFor(p => p.IsActive, _ => isActive)
+            .RuleFor(p => p.PartnerLimits, _ => [])
+            .Generate();
+        partner.Manager = new AutoFaker<Employee>().Generate();
+
+        if (limit > 0)
+        {
+            var partnerLimit = new PartnerPromoCodeLimit
+            {
+                Id = Guid.NewGuid(),
+                Partner = partner,
+                Limit = limit,
+                IssuedCount = issuedCount,
+                CreatedAt = DateTimeOffset.UtcNow.AddDays(-1),
+                EndAt = DateTimeOffset.UtcNow.AddDays(30)
+            };
+            partner.PartnerLimits.Add(partnerLimit);
+        }
+
+        return partner;
+    }
+
+    private static Preference CreatePreference(Guid preferenceId)
+    {
+        return new AutoFaker<Preference>()
+            .RuleFor(p => p.Id, _ => preferenceId)
+            .Generate();
     }
 }