feat: add additional repository

src/SanctionsSearch.Worker.Tests/Faker/AddressFaker.cs

@@ -0,0 +1,13 @@
+namespace SanctionsSearch.Worker.Tests.Faker;
+
+class AddressFaker : Faker<Address>
+{
+  public AddressFaker()
+  {
+    RuleFor(x => x.SdnId, f => f.Random.Int(1, int.MaxValue));
+    RuleFor(x => x.StreetAddress, f => f.Address.StreetAddress());
+    RuleFor(x => x.CityProvincePostal, f => $"{f.Address.City()}, {f.Address.StateAbbr()} {f.Address.ZipCode()}");
+    RuleFor(x => x.Country, f => f.Address.Country());
+    RuleFor(x => x.Remarks, f => f.Lorem.Sentence());
+  }
+}

src/SanctionsSearch.Worker.Tests/Faker/AliasFaker.cs

@@ -0,0 +1,12 @@
+namespace SanctionsSearch.Worker.Tests.Faker;
+
+class AliasFaker : Faker<Alias>
+{
+  public AliasFaker()
+  {
+    RuleFor(x => x.SdnId, f => f.Random.Int(1, int.MaxValue));
+    RuleFor(x => x.Type, f => f.Lorem.Word());
+    RuleFor(x => x.Name, f => f.Person.FullName);
+    RuleFor(x => x.Remarks, f => f.Lorem.Sentence());
+  }
+}

src/SanctionsSearch.Worker.Tests/Faker/CommentFaker.cs

@@ -0,0 +1,10 @@
+namespace SanctionsSearch.Worker.Tests.Faker;
+
+class CommentFaker : Faker<Comment>
+{
+  public CommentFaker()
+  {
+    RuleFor(x => x.SdnId, f => f.Random.Int(1, int.MaxValue));
+    RuleFor(x => x.Remarks, f => f.Lorem.Sentence());
+  }
+}

src/SanctionsSearch.Worker.Tests/Integration/AddressRepositoryTests.cs

@@ -0,0 +1,86 @@
+namespace SanctionsSearch.Worker.Tests.Integration;
+
+public class AddressRepositoryTests : RepositoryTest
+{
+  private readonly AddressRepository _repository;
+  private readonly AddressFaker _faker = new();
+
+  public AddressRepositoryTests()
+  {
+    var loggerFactory = LoggerFactory.Create(builder => builder.ClearProviders());
+    _repository = new(_context, new Logger<AddressRepository>(loggerFactory));
+  }
+
+  [Fact]
+  public async Task Upsert_WithNewEntity_ShouldAddEntityToDatabase()
+  {
+    var now = DateTimeOffset.UtcNow;
+    _timeProvider.Setup(x => x.GetUtcNow()).Returns(now);
+
+    var entity = _faker.Generate();
+
+    await _repository.Upsert(entity);
+    await _context.SaveChangesAsync();
+
+    var result = await _context.Set<Address>().FindAsync(entity.Id);
+
+    result.Should().BeEquivalentTo(entity);
+    result!.CreatedAt.Should().Be(now.DateTime);
+    result.UpdatedAt.Should().Be(now.DateTime);
+  }
+
+  [Fact]
+  public async Task Upsert_WithExistingEntity_ShouldUpdateEntityInDatabase()
+  {
+    var createdTimeStamp = DateTimeOffset.UtcNow;
+    var updatedTimeStamp = createdTimeStamp.AddSeconds(2);
+
+    _timeProvider.Setup(x => x.GetUtcNow()).Returns(createdTimeStamp);
+
+    var entity = _faker.Generate();
+
+    // Insert the entity
+    await _repository.Upsert(entity);
+    await _context.SaveChangesAsync();
+
+    // Assert the entity was created
+    var createdEntity = await _context.Set<Address>().FindAsync(entity.Id);
+
+    createdEntity.Should().BeEquivalentTo(entity);
+    createdEntity!.CreatedAt.Should().Be(createdTimeStamp.DateTime);
+    createdEntity.UpdatedAt.Should().Be(createdTimeStamp.DateTime);
+
+    _timeProvider.Setup(x => x.GetUtcNow()).Returns(updatedTimeStamp);
+
+    // Update the entity
+    entity.StreetAddress = "Updated";
+    await _repository.Upsert(entity);
+    await _context.SaveChangesAsync();
+
+    // Assert the entity was updated
+    var result = await _context.Set<Address>().FindAsync(entity.Id);
+
+    result.Should().BeEquivalentTo(entity);
+    result!.CreatedAt.Should().BeSameDateAs(createdTimeStamp.DateTime);
+    result.UpdatedAt.Should().BeSameDateAs(updatedTimeStamp.DateTime);
+  }
+
+  [Fact]
+  public async Task Find_WithPredicate_ShouldReturnEntitiesMatchingPredicate()
+  {
+    var entities = _faker.Generate(3);
+
+    foreach (var entity in entities)
+    {
+      await _repository.Upsert(entity);
+    }
+
+    await _context.SaveChangesAsync();
+
+    var target = entities[0];
+    var result = await _repository.Find(x => x.Id == target.Id);
+
+    result.Should().HaveCount(1);
+    result.First().Should().BeEquivalentTo(target);
+  }
+}

src/SanctionsSearch.Worker.Tests/Integration/AliasRepositoryTests.cs

@@ -0,0 +1,86 @@
+namespace SanctionsSearch.Worker.Tests.Integration;
+
+public class AliasRepositoryTests : RepositoryTest
+{
+  private readonly AliasRepository _repository;
+  private readonly AliasFaker _faker = new();
+
+  public AliasRepositoryTests()
+  {
+    var loggerFactory = LoggerFactory.Create(builder => builder.ClearProviders());
+    _repository = new(_context, new Logger<AliasRepository>(loggerFactory));
+  }
+
+  [Fact]
+  public async Task Upsert_WithNewEntity_ShouldAddEntityToDatabase()
+  {
+    var now = DateTimeOffset.UtcNow;
+    _timeProvider.Setup(x => x.GetUtcNow()).Returns(now);
+
+    var entity = _faker.Generate();
+
+    await _repository.Upsert(entity);
+    await _context.SaveChangesAsync();
+
+    var result = await _context.Set<Alias>().FindAsync(entity.Id);
+
+    result.Should().BeEquivalentTo(entity);
+    result!.CreatedAt.Should().Be(now.DateTime);
+    result.UpdatedAt.Should().Be(now.DateTime);
+  }
+
+  [Fact]
+  public async Task Upsert_WithExistingEntity_ShouldUpdateEntityInDatabase()
+  {
+    var createdTimeStamp = DateTimeOffset.UtcNow;
+    var updatedTimeStamp = createdTimeStamp.AddSeconds(2);
+
+    _timeProvider.Setup(x => x.GetUtcNow()).Returns(createdTimeStamp);
+
+    var entity = _faker.Generate();
+
+    // Insert the entity
+    await _repository.Upsert(entity);
+    await _context.SaveChangesAsync();
+
+    // Assert the entity was created
+    var createdEntity = await _context.Set<Alias>().FindAsync(entity.Id);
+
+    createdEntity.Should().BeEquivalentTo(entity);
+    createdEntity!.CreatedAt.Should().Be(createdTimeStamp.DateTime);
+    createdEntity.UpdatedAt.Should().Be(createdTimeStamp.DateTime);
+
+    _timeProvider.Setup(x => x.GetUtcNow()).Returns(updatedTimeStamp);
+
+    // Update the entity
+    entity.Remarks = "Updated";
+    await _repository.Upsert(entity);
+    await _context.SaveChangesAsync();
+
+    // Assert the entity was updated
+    var result = await _context.Set<Alias>().FindAsync(entity.Id);
+
+    result.Should().BeEquivalentTo(entity);
+    result!.CreatedAt.Should().BeSameDateAs(createdTimeStamp.DateTime);
+    result.UpdatedAt.Should().BeSameDateAs(updatedTimeStamp.DateTime);
+  }
+
+  [Fact]
+  public async Task Find_WithPredicate_ShouldReturnEntitiesMatchingPredicate()
+  {
+    var entities = _faker.Generate(3);
+
+    foreach (var entity in entities)
+    {
+      await _repository.Upsert(entity);
+    }
+
+    await _context.SaveChangesAsync();
+
+    var target = entities[0];
+    var result = await _repository.Find(x => x.Id == target.Id);
+
+    result.Should().HaveCount(1);
+    result.First().Should().BeEquivalentTo(target);
+  }
+}

src/SanctionsSearch.Worker.Tests/Integration/CommentRepositoryTests.cs

@@ -0,0 +1,86 @@
+namespace SanctionsSearch.Worker.Tests.Integration;
+
+public class CommentRepositoryTests : RepositoryTest
+{
+  private readonly CommentRepository _repository;
+  private readonly CommentFaker _faker = new();
+
+  public CommentRepositoryTests()
+  {
+    var loggerFactory = LoggerFactory.Create(builder => builder.ClearProviders());
+    _repository = new(_context, new Logger<CommentRepository>(loggerFactory));
+  }
+
+  [Fact]
+  public async Task Upsert_WithNewEntity_ShouldAddEntityToDatabase()
+  {
+    var now = DateTimeOffset.UtcNow;
+    _timeProvider.Setup(x => x.GetUtcNow()).Returns(now);
+
+    var entity = _faker.Generate();
+
+    await _repository.Upsert(entity);
+    await _context.SaveChangesAsync();
+
+    var result = await _context.Set<Comment>().FindAsync(entity.Id);
+
+    result.Should().BeEquivalentTo(entity);
+    result!.CreatedAt.Should().Be(now.DateTime);
+    result.UpdatedAt.Should().Be(now.DateTime);
+  }
+
+  [Fact]
+  public async Task Upsert_WithExistingEntity_ShouldUpdateEntityInDatabase()
+  {
+    var createdTimeStamp = DateTimeOffset.UtcNow;
+    var updatedTimeStamp = createdTimeStamp.AddSeconds(2);
+
+    _timeProvider.Setup(x => x.GetUtcNow()).Returns(createdTimeStamp);
+
+    var entity = _faker.Generate();
+
+    // Insert the entity
+    await _repository.Upsert(entity);
+    await _context.SaveChangesAsync();
+
+    // Assert the entity was created
+    var createdEntity = await _context.Set<Comment>().FindAsync(entity.Id);
+
+    createdEntity.Should().BeEquivalentTo(entity);
+    createdEntity!.CreatedAt.Should().Be(createdTimeStamp.DateTime);
+    createdEntity.UpdatedAt.Should().Be(createdTimeStamp.DateTime);
+
+    _timeProvider.Setup(x => x.GetUtcNow()).Returns(updatedTimeStamp);
+
+    // Update the entity
+    entity.Remarks = "Updated";
+    await _repository.Upsert(entity);
+    await _context.SaveChangesAsync();
+
+    // Assert the entity was updated
+    var result = await _context.Set<Comment>().FindAsync(entity.Id);
+
+    result.Should().BeEquivalentTo(entity);
+    result!.CreatedAt.Should().BeSameDateAs(createdTimeStamp.DateTime);
+    result.UpdatedAt.Should().BeSameDateAs(updatedTimeStamp.DateTime);
+  }
+
+  [Fact]
+  public async Task Find_WithPredicate_ShouldReturnEntitiesMatchingPredicate()
+  {
+    var entities = _faker.Generate(3);
+
+    foreach (var entity in entities)
+    {
+      await _repository.Upsert(entity);
+    }
+
+    await _context.SaveChangesAsync();
+
+    var target = entities[0];
+    var result = await _repository.Find(x => x.Id == target.Id);
+
+    result.Should().HaveCount(1);
+    result.First().Should().BeEquivalentTo(target);
+  }
+}

src/SanctionsSearch.Worker.Tests/Integration/RepositoryTest.cs

@@ -0,0 +1,31 @@
+namespace SanctionsSearch.Worker.Tests.Integration;
+
+public class RepositoryTest : IAsyncLifetime
+{
+  private readonly AppDbContext _appDbContext;
+  protected readonly Mock<TimeProvider> _timeProvider = new();
+  protected readonly DbContext _context;
+
+  public RepositoryTest()
+  {
+    var options = new DbOptions { DatabaseName = $"{Guid.NewGuid()}.db" };
+    var context = new AppDbContext(options, _timeProvider.Object);
+
+    _appDbContext = context;
+    _context = context;
+  }
+
+  public async Task InitializeAsync()
+  {
+    await _context.Database.MigrateAsync();
+  }
+
+  public async Task DisposeAsync()
+  {
+    await _appDbContext.DisposeAsync();
+
+    SqliteConnection.ClearAllPools();
+
+    File.Delete(_appDbContext.DatabasePath);
+  }
+}

src/SanctionsSearch.Worker.Tests/Integration/SdnRepositoryTests.cs

@@ -1,19 +1,14 @@
 namespace SanctionsSearch.Worker.Tests.Integration;
 
-public class SdnRepositoryTests : IAsyncLifetime
+public class SdnRepositoryTests : RepositoryTest
 {
-  private readonly AppDbContext _context;
-  private readonly SdnRepository _sdnRepository;
-  private readonly SdnFaker _sdnFaker = new();
-  private readonly Mock<TimeProvider> _timeProvider = new();
+  private readonly SdnRepository _repository;
+  private readonly SdnFaker _faker = new();
 
   public SdnRepositoryTests()
   {
     var loggerFactory = LoggerFactory.Create(builder => builder.ClearProviders());
-    var options = new DbOptions { DatabaseName = $"{Guid.NewGuid()}.db" };
-
-    _context = new AppDbContext(options, _timeProvider.Object);
-    _sdnRepository = new SdnRepository(_context, new Logger<SdnRepository>(loggerFactory));
+    _repository = new SdnRepository(_context, new Logger<SdnRepository>(loggerFactory));
   }
 
   [Fact]
@@ -22,14 +17,14 @@ public class SdnRepositoryTests : IAsyncLifetime
     var now = DateTimeOffset.UtcNow;
     _timeProvider.Setup(x => x.GetUtcNow()).Returns(now);
 
-    var sdn = _sdnFaker.Generate();
+    var entity = _faker.Generate();
 
-    await _sdnRepository.Upsert(sdn);
+    await _repository.Upsert(entity);
     await _context.SaveChangesAsync();
 
-    var result = await _context.Sdns.FindAsync(sdn.Id);
+    var result = await _context.Set<Sdn>().FindAsync(entity.Id);
 
-    result.Should().BeEquivalentTo(sdn);
+    result.Should().BeEquivalentTo(entity);
     result!.CreatedAt.Should().Be(now.DateTime);
     result.UpdatedAt.Should().Be(now.DateTime);
   }
@@ -42,30 +37,30 @@ public class SdnRepositoryTests : IAsyncLifetime
 
     _timeProvider.Setup(x => x.GetUtcNow()).Returns(createdTimeStamp);
 
-    var sdn = _sdnFaker.Generate();
+    var entity = _faker.Generate();
 
     // Insert the entity
-    await _sdnRepository.Upsert(sdn);
+    await _repository.Upsert(entity);
     await _context.SaveChangesAsync();
 
     // Assert the entity was created
-    var createdSdn = await _context.Sdns.FindAsync(sdn.Id);
+    var createdEntity = await _context.Set<Sdn>().FindAsync(entity.Id);
 
-    createdSdn.Should().BeEquivalentTo(sdn);
-    createdSdn!.CreatedAt.Should().Be(createdTimeStamp.DateTime);
-    createdSdn.UpdatedAt.Should().Be(createdTimeStamp.DateTime);
+    createdEntity.Should().BeEquivalentTo(entity);
+    createdEntity!.CreatedAt.Should().Be(createdTimeStamp.DateTime);
+    createdEntity.UpdatedAt.Should().Be(createdTimeStamp.DateTime);
 
     _timeProvider.Setup(x => x.GetUtcNow()).Returns(updatedTimeStamp);
 
     // Update the entity
-    sdn.Name = "Updated";
-    await _sdnRepository.Upsert(sdn);
+    entity.Name = "Updated";
+    await _repository.Upsert(entity);
     await _context.SaveChangesAsync();
 
     // Assert the entity was updated
-    var result = await _context.Sdns.FindAsync(sdn.Id);
+    var result = await _context.Set<Sdn>().FindAsync(entity.Id);
 
-    result.Should().BeEquivalentTo(sdn);
+    result.Should().BeEquivalentTo(entity);
     result!.CreatedAt.Should().BeSameDateAs(createdTimeStamp.DateTime);
     result.UpdatedAt.Should().BeSameDateAs(updatedTimeStamp.DateTime);
   }
@@ -73,33 +68,19 @@ public class SdnRepositoryTests : IAsyncLifetime
   [Fact]
   public async Task Find_WithPredicate_ShouldReturnEntitiesMatchingPredicate()
   {
-    var sdns = _sdnFaker.Generate(3);
+    var entities = _faker.Generate(3);
 
-    foreach (var sdn in sdns)
+    foreach (var entity in entities)
     {
-      await _sdnRepository.Upsert(sdn);
+      await _repository.Upsert(entity);
     }
 
     await _context.SaveChangesAsync();
 
-    var target = sdns[0];
-    var result = await _sdnRepository.Find(x => x.Id == target.Id);
+    var target = entities[0];
+    var result = await _repository.Find(x => x.Id == target.Id);
 
     result.Should().HaveCount(1);
     result.First().Should().BeEquivalentTo(target);
   }
-
-  public async Task InitializeAsync()
-  {
-    await _context.Database.MigrateAsync();
-  }
-
-  public async Task DisposeAsync()
-  {
-    await _context.DisposeAsync();
-
-    SqliteConnection.ClearAllPools();
-
-    File.Delete(_context.DatabasePath);
-  }
 }

src/SanctionsSearch.Worker.Tests/Unit/AddressRepositoryTests.cs

@@ -0,0 +1,63 @@
+namespace SanctionsSearch.Worker.Tests.Unit;
+
+public class AddressRepositoryTests
+{
+  private readonly Mock<DbContext> _context = new();
+  private readonly Mock<ILogger<AddressRepository>> _logger = new();
+  private readonly AddressFaker _faker = new();
+  private readonly AddressRepository _repository;
+
+  public AddressRepositoryTests()
+  {
+    _repository = new AddressRepository(_context.Object, _logger.Object);
+  }
+
+  [Fact]
+  public async Task Upsert_WhenExceptionIsThrown_ItShouldLogError()
+  {
+    var entity = _faker.Generate();
+    var mockSet = new Mock<DbSet<Address>>();
+
+    mockSet
+      .Setup(x => x.FindAsync(entity.Id))
+      .Throws<Exception>();
+
+    _context
+      .Setup(x => x.Set<Address>())
+      .Returns(mockSet.Object);
+
+    await _repository.Upsert(entity);
+
+    _logger.Verify(
+      x => x.Log(
+        LogLevel.Error,
+        It.IsAny<EventId>(),
+        It.IsAny<It.IsAnyType>(),
+        It.IsAny<Exception>(),
+        It.IsAny<Func<It.IsAnyType, Exception?, string>>()
+      )
+    );
+  }
+
+  [Fact]
+  public async Task Find_WhenExceptionIsThrown_ItShouldReturnEmptyListAndLogError()
+  {
+    _context
+      .Setup(x => x.Set<Address>())
+      .Throws<Exception>();
+
+    var result = await _repository.Find(x => x.Id == 1);
+
+    result.Should().BeEmpty();
+
+    _logger.Verify(
+      x => x.Log(
+        LogLevel.Error,
+        It.IsAny<EventId>(),
+        It.IsAny<It.IsAnyType>(),
+        It.IsAny<Exception>(),
+        It.IsAny<Func<It.IsAnyType, Exception?, string>>()
+      )
+    );
+  }
+}

src/SanctionsSearch.Worker.Tests/Unit/AliasRepositoryTests.cs

@@ -0,0 +1,63 @@
+namespace SanctionsSearch.Worker.Tests.Unit;
+
+public class AliasRepositoryTests
+{
+  private readonly Mock<DbContext> _context = new();
+  private readonly Mock<ILogger<AliasRepository>> _logger = new();
+  private readonly AliasFaker _faker = new();
+  private readonly AliasRepository _repository;
+
+  public AliasRepositoryTests()
+  {
+    _repository = new AliasRepository(_context.Object, _logger.Object);
+  }
+
+  [Fact]
+  public async Task Upsert_WhenExceptionIsThrown_ItShouldLogError()
+  {
+    var entity = _faker.Generate();
+    var mockSet = new Mock<DbSet<Alias>>();
+
+    mockSet
+      .Setup(x => x.FindAsync(entity.Id))
+      .Throws<Exception>();
+
+    _context
+      .Setup(x => x.Set<Alias>())
+      .Returns(mockSet.Object);
+
+    await _repository.Upsert(entity);
+
+    _logger.Verify(
+      x => x.Log(
+        LogLevel.Error,
+        It.IsAny<EventId>(),
+        It.IsAny<It.IsAnyType>(),
+        It.IsAny<Exception>(),
+        It.IsAny<Func<It.IsAnyType, Exception?, string>>()
+      )
+    );
+  }
+
+  [Fact]
+  public async Task Find_WhenExceptionIsThrown_ItShouldReturnEmptyListAndLogError()
+  {
+    _context
+      .Setup(x => x.Set<Alias>())
+      .Throws<Exception>();
+
+    var result = await _repository.Find(x => x.Id == 1);
+
+    result.Should().BeEmpty();
+
+    _logger.Verify(
+      x => x.Log(
+        LogLevel.Error,
+        It.IsAny<EventId>(),
+        It.IsAny<It.IsAnyType>(),
+        It.IsAny<Exception>(),
+        It.IsAny<Func<It.IsAnyType, Exception?, string>>()
+      )
+    );
+  }
+}

src/SanctionsSearch.Worker.Tests/Unit/CommentRepositoryTests.cs

@@ -0,0 +1,63 @@
+namespace SanctionsSearch.Worker.Tests.Unit;
+
+public class CommentRepositoryTests
+{
+  private readonly Mock<DbContext> _context = new();
+  private readonly Mock<ILogger<CommentRepository>> _logger = new();
+  private readonly CommentFaker _faker = new();
+  private readonly CommentRepository _repository;
+
+  public CommentRepositoryTests()
+  {
+    _repository = new CommentRepository(_context.Object, _logger.Object);
+  }
+
+  [Fact]
+  public async Task Upsert_WhenExceptionIsThrown_ItShouldLogError()
+  {
+    var entity = _faker.Generate();
+    var mockSet = new Mock<DbSet<Comment>>();
+
+    mockSet
+      .Setup(x => x.FindAsync(entity.Id))
+      .Throws<Exception>();
+
+    _context
+      .Setup(x => x.Set<Comment>())
+      .Returns(mockSet.Object);
+
+    await _repository.Upsert(entity);
+
+    _logger.Verify(
+      x => x.Log(
+        LogLevel.Error,
+        It.IsAny<EventId>(),
+        It.IsAny<It.IsAnyType>(),
+        It.IsAny<Exception>(),
+        It.IsAny<Func<It.IsAnyType, Exception?, string>>()
+      )
+    );
+  }
+
+  [Fact]
+  public async Task Find_WhenExceptionIsThrown_ItShouldReturnEmptyListAndLogError()
+  {
+    _context
+      .Setup(x => x.Set<Comment>())
+      .Throws<Exception>();
+
+    var result = await _repository.Find(x => x.Id == 1);
+
+    result.Should().BeEmpty();
+
+    _logger.Verify(
+      x => x.Log(
+        LogLevel.Error,
+        It.IsAny<EventId>(),
+        It.IsAny<It.IsAnyType>(),
+        It.IsAny<Exception>(),
+        It.IsAny<Func<It.IsAnyType, Exception?, string>>()
+      )
+    );
+  }
+}

src/SanctionsSearch.Worker.Tests/Unit/SdnRepositoryTests.cs

@@ -4,29 +4,29 @@ public class SdnRepositoryTests
 {
   private readonly Mock<DbContext> _context = new();
   private readonly Mock<ILogger<SdnRepository>> _logger = new();
-  private readonly SdnFaker _sdnFaker = new();
-  private readonly SdnRepository _sdnRepository;
+  private readonly SdnFaker _faker = new();
+  private readonly SdnRepository _repository;
 
   public SdnRepositoryTests()
   {
-    _sdnRepository = new SdnRepository(_context.Object, _logger.Object);
+    _repository = new SdnRepository(_context.Object, _logger.Object);
   }
 
   [Fact]
   public async Task Upsert_WhenExceptionIsThrown_ItShouldLogError()
   {
-    var sdn = _sdnFaker.Generate();
+    var entity = _faker.Generate();
     var mockSet = new Mock<DbSet<Sdn>>();
 
     mockSet
-      .Setup(x => x.FindAsync(sdn.Id))
+      .Setup(x => x.FindAsync(entity.Id))
       .Throws<Exception>();
 
     _context
       .Setup(x => x.Set<Sdn>())
       .Returns(mockSet.Object);
 
-    await _sdnRepository.Upsert(sdn);
+    await _repository.Upsert(entity);
 
     _logger.Verify(
       x => x.Log(
@@ -46,7 +46,7 @@ public class SdnRepositoryTests
       .Setup(x => x.Set<Sdn>())
       .Throws<Exception>();
 
-    var result = await _sdnRepository.Find(x => x.Id == 1);
+    var result = await _repository.Find(x => x.Id == 1);
 
     result.Should().BeEmpty();
 

src/SanctionsSearch.Worker/Interfaces/IAddressRepository.cs

@@ -0,0 +1,5 @@
+namespace SanctionsSearch.Worker.Interfaces;
+
+interface IAddressRepository : IRepository<Address>
+{
+}

src/SanctionsSearch.Worker/Interfaces/IAliasRepository.cs

@@ -0,0 +1,5 @@
+namespace SanctionsSearch.Worker.Interfaces;
+
+interface IAliasRepository : IRepository<Alias>
+{
+}

src/SanctionsSearch.Worker/Interfaces/ICommentRepository.cs

@@ -0,0 +1,5 @@
+namespace SanctionsSearch.Worker.Interfaces;
+
+interface ICommentRepository : IRepository<Comment>
+{
+}

src/SanctionsSearch.Worker/Interfaces/IUnitOfWork.cs

@@ -3,5 +3,8 @@ namespace SanctionsSearch.Worker.Interfaces;
 interface IUnitOfWork
 {
   ISdnRepository Sdns { get; }
+  IAddressRepository Addresses { get; }
+  IAliasRepository Aliases { get; }
+  ICommentRepository Comments { get; }
   Task SaveChangesAsync();
 }

src/SanctionsSearch.Worker/Persistence/AddressRepository.cs

@@ -0,0 +1,8 @@
+namespace SanctionsSearch.Worker.Persistence;
+
+class AddressRepository(
+  DbContext dbContext,
+  ILogger<AddressRepository> logger
+) : EfRepository<Address>(dbContext, logger), IAddressRepository
+{
+}

src/SanctionsSearch.Worker/Persistence/AliasRepository.cs

@@ -0,0 +1,8 @@
+namespace SanctionsSearch.Worker.Persistence;
+
+class AliasRepository(
+  DbContext dbContext,
+  ILogger<AliasRepository> logger
+) : EfRepository<Alias>(dbContext, logger), IAliasRepository
+{
+}

src/SanctionsSearch.Worker/Persistence/CommentRepository.cs

@@ -0,0 +1,8 @@
+namespace SanctionsSearch.Worker.Persistence;
+
+class CommentRepository(
+  DbContext dbContext,
+  ILogger<CommentRepository> logger
+) : EfRepository<Comment>(dbContext, logger), ICommentRepository
+{
+}

src/SanctionsSearch.Worker/Persistence/EfUnitOfWork.cs

@@ -4,6 +4,9 @@ class EfUnitOfWork(AppDbContext context, ILoggerFactory loggerFactory) : IUnitOf
 {
   private readonly AppDbContext _context = context;
   public ISdnRepository Sdns { get; } = new SdnRepository(context, loggerFactory.CreateLogger<SdnRepository>());
+  public IAddressRepository Addresses { get; } = new AddressRepository(context, loggerFactory.CreateLogger<AddressRepository>());
+  public IAliasRepository Aliases { get; } = new AliasRepository(context, loggerFactory.CreateLogger<AliasRepository>());
+  public ICommentRepository Comments { get; } = new CommentRepository(context, loggerFactory.CreateLogger<CommentRepository>());
 
   public async Task SaveChangesAsync()
   {

src/SanctionsSearch.Worker/Program.cs

@@ -63,7 +63,15 @@ class Program
     builder.Services.AddScoped(rs => rs.GetRequiredService<IOptionsSnapshot<DbOptions>>().Value);
 
     builder.Services.AddSingleton(TimeProvider.System);
+    builder.Services.AddScoped<IOfacFileService, OfacFileService>();
+
+    builder.Services.AddScoped<ISdnRepository, SdnRepository>();
+    builder.Services.AddScoped<IAddressRepository, AddressRepository>();
+    builder.Services.AddScoped<IAliasRepository, AliasRepository>();
+    builder.Services.AddScoped<ICommentRepository, CommentRepository>();
+    builder.Services.AddScoped<IUnitOfWork, EfUnitOfWork>();
     builder.Services.AddDbContext<AppDbContext>();
+
     builder.Services.AddHostedService<Worker>();
 
     return builder;