feat(unitFilter): Оптимизация фильрации юнитов. Проверка значений аттрибутов теперь выполняется в 2 запроса:

- проверяем доступные в базе значения
- проверяем наличие значений в юнитах по id значений

PARR.DAL.Tests/Services/UnitFilterService/Matchers/UnitFieldMatcherTests.cs

@@ -0,0 +1,326 @@
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using PARR.Core.Repositories.Interfaces.Unit;
+using PARR.Core.Services.UnitFilterService.Matchers;
+using PARR.Domain.Entities.JobEntities;
+
+namespace PARR.Core.Tests.Services.UnitFilterService.Matchers
+{
+    public class UnitFieldMatcherTests
+    {
+        private readonly Mock<IUnitRepository> _unitRepoMock;
+        private readonly Mock<IUnitFieldValueRepository> _fieldValueRepoMock;
+        private readonly UnitFieldMatcher _sut;
+
+        public UnitFieldMatcherTests()
+        {
+            _unitRepoMock = new Mock<IUnitRepository>();
+            _fieldValueRepoMock = new Mock<IUnitFieldValueRepository>();
+            var logger = NullLoggerFactory.Instance.CreateLogger<UnitFieldMatcher>();
+            _sut = new UnitFieldMatcher(
+                _unitRepoMock.Object,
+                _fieldValueRepoMock.Object,
+                logger);
+        }
+
+        /// <summary>
+        /// Если фильтры не заданы, возвращается исходный набор юнитов без изменений.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_NoFilters_ReturnsAllUnitIds()
+        {
+            // Arrange
+            var unitIds = new List<Guid> { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() };
+
+            // Act
+            var result = await _sut.MatchAsync(unitIds, Enumerable.Empty<JobFieldFilter>());
+
+            // Assert
+            Assert.Equal(unitIds.Count, result.Count);
+            Assert.Equal(unitIds, result);
+            _fieldValueRepoMock.Verify(
+                r => r.FindValueIdsByMaskAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()),
+                Times.Never);
+        }
+
+        /// <summary>
+        /// Прямой фильтр оставляет только юниты, имеющие совпадающие значения.
+        /// Проверяется логика IntersectWith.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_SingleDirectFilter_IntersectsWithMatchingUnits()
+        {
+            // Arrange
+            var unit1 = Guid.NewGuid();
+            var unit2 = Guid.NewGuid();
+            var unit3 = Guid.NewGuid();
+            var unitIds = new List<Guid> { unit1, unit2, unit3 };
+
+            var fieldId = Guid.NewGuid();
+            var valueId = Guid.NewGuid();
+
+            var filters = new List<JobFieldFilter>
+        {
+            new() { FieldId = fieldId, ValueMask = "коммутатор", IsInverse = false }
+        };
+
+            _fieldValueRepoMock
+                .Setup(r => r.FindValueIdsByMaskAsync("коммутатор", It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid> { valueId });
+
+            _unitRepoMock
+                .Setup(r => r.FindUnitIdsByValueIdsAsync(
+                    It.IsAny<IReadOnlyList<Guid>>(),
+                    fieldId,
+                    It.Is<IReadOnlyList<Guid>>(v => v.Contains(valueId)),
+                    It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid> { unit1, unit3 });
+
+            // Act
+            var result = await _sut.MatchAsync(unitIds, filters);
+
+            // Assert
+            Assert.Equal(2, result.Count);
+            Assert.Contains(unit1, result);
+            Assert.Contains(unit3, result);
+            Assert.DoesNotContain(unit2, result);
+        }
+
+        /// <summary>
+        /// Инверсный фильтр исключает юниты, имеющие совпадающие значения.
+        /// Проверяется логика ExceptWith.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_SingleInverseFilter_ExcludesMatchingUnits()
+        {
+            // Arrange
+            var unit1 = Guid.NewGuid();
+            var unit2 = Guid.NewGuid();
+            var unit3 = Guid.NewGuid();
+            var unitIds = new List<Guid> { unit1, unit2, unit3 };
+
+            var fieldId = Guid.NewGuid();
+            var valueId = Guid.NewGuid();
+
+            var filters = new List<JobFieldFilter>
+        {
+            new() { FieldId = fieldId, ValueMask = "1", IsInverse = true }
+        };
+
+            _fieldValueRepoMock
+                .Setup(r => r.FindValueIdsByMaskAsync("1", It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid> { valueId });
+
+            _unitRepoMock
+                .Setup(r => r.FindUnitIdsByValueIdsAsync(
+                    It.IsAny<IReadOnlyList<Guid>>(),
+                    fieldId,
+                    It.Is<IReadOnlyList<Guid>>(v => v.Contains(valueId)),
+                    It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid> { unit2 });
+
+            // Act
+            var result = await _sut.MatchAsync(unitIds, filters);
+
+            // Assert
+            Assert.Equal(2, result.Count);
+            Assert.Contains(unit1, result);
+            Assert.Contains(unit3, result);
+            Assert.DoesNotContain(unit2, result);
+        }
+
+        /// <summary>
+        /// Несколько фильтров применяются последовательно (AND).
+        /// Каждый следующий фильтр сужает набор, полученный от предыдущего.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_MultipleFilters_AppliesSequentially()
+        {
+            // Arrange
+            var unit1 = Guid.NewGuid();
+            var unit2 = Guid.NewGuid();
+            var unit3 = Guid.NewGuid();
+            var unit4 = Guid.NewGuid();
+            var unitIds = new List<Guid> { unit1, unit2, unit3, unit4 };
+
+            var fieldId1 = Guid.NewGuid();
+            var fieldId2 = Guid.NewGuid();
+            var valueId1 = Guid.NewGuid();
+            var valueId2 = Guid.NewGuid();
+
+            var filters = new List<JobFieldFilter>
+        {
+            new() { FieldId = fieldId1, ValueMask = "СХД", IsInverse = false },
+            new() { FieldId = fieldId2, ValueMask = "коммутатор", IsInverse = false }
+        };
+
+            // Первый фильтр: значения найдены для unit1, unit2, unit3
+            _fieldValueRepoMock
+                .Setup(r => r.FindValueIdsByMaskAsync("СХД", It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid> { valueId1 });
+            _unitRepoMock
+                .Setup(r => r.FindUnitIdsByValueIdsAsync(
+                    It.Is<IReadOnlyList<Guid>>(ids => ids.Count == 4),
+                    fieldId1,
+                    It.Is<IReadOnlyList<Guid>>(v => v.Contains(valueId1)),
+                    It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid> { unit1, unit2, unit3 });
+
+            // Второй фильтр: из оставшихся 3 юнитов значение найдено для unit1 и unit3
+            _fieldValueRepoMock
+                .Setup(r => r.FindValueIdsByMaskAsync("коммутатор", It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid> { valueId2 });
+            _unitRepoMock
+                .Setup(r => r.FindUnitIdsByValueIdsAsync(
+                    It.Is<IReadOnlyList<Guid>>(ids => ids.Count == 3),
+                    fieldId2,
+                    It.Is<IReadOnlyList<Guid>>(v => v.Contains(valueId2)),
+                    It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid> { unit1, unit3 });
+
+            // Act
+            var result = await _sut.MatchAsync(unitIds, filters);
+
+            // Assert
+            Assert.Equal(2, result.Count);
+            Assert.Contains(unit1, result);
+            Assert.Contains(unit3, result);
+        }
+
+        /// <summary>
+        /// Если прямой фильтр не нашёл ни одного значения, результат пуст.
+        /// Проверяется раннее прерывание.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_NoMatchingValues_DirectFilter_ReturnsEmpty()
+        {
+            // Arrange
+            var unitIds = new List<Guid> { Guid.NewGuid(), Guid.NewGuid() };
+            var fieldId = Guid.NewGuid();
+
+            var filters = new List<JobFieldFilter>
+        {
+            new() { FieldId = fieldId, ValueMask = "несуществующее", IsInverse = false }
+        };
+
+            _fieldValueRepoMock
+                .Setup(r => r.FindValueIdsByMaskAsync("несуществующее", It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid>());
+
+            // Act
+            var result = await _sut.MatchAsync(unitIds, filters);
+
+            // Assert
+            Assert.Empty(result);
+            _unitRepoMock.Verify(
+                r => r.FindUnitIdsByValueIdsAsync(
+                    It.IsAny<IReadOnlyList<Guid>>(),
+                    It.IsAny<Guid>(),
+                    It.IsAny<IReadOnlyList<Guid>>(),
+                    It.IsAny<CancellationToken>()),
+                Times.Never);
+        }
+
+        /// <summary>
+        /// Если инверсный фильтр не нашёл ни одного значения, все юниты проходят.
+        /// Исключать нечего, поэтому FindUnitIdsByValueIdsAsync не вызывается.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_NoMatchingValues_InverseFilter_ReturnsAll()
+        {
+            // Arrange
+            var unit1 = Guid.NewGuid();
+            var unit2 = Guid.NewGuid();
+            var unitIds = new List<Guid> { unit1, unit2 };
+            var fieldId = Guid.NewGuid();
+
+            var filters = new List<JobFieldFilter>
+        {
+            new() { FieldId = fieldId, ValueMask = "несуществующее", IsInverse = true }
+        };
+
+            _fieldValueRepoMock
+                .Setup(r => r.FindValueIdsByMaskAsync("несуществующее", It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid>());
+
+            // Act
+            var result = await _sut.MatchAsync(unitIds, filters);
+
+            // Assert
+            Assert.Equal(2, result.Count);
+            Assert.Contains(unit1, result);
+            Assert.Contains(unit2, result);
+        }
+
+        /// <summary>
+        /// Фильтр с пустой маской пропускается без вызова репозиториев.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_EmptyMask_SkipsFilter()
+        {
+            // Arrange
+            var unitIds = new List<Guid> { Guid.NewGuid(), Guid.NewGuid() };
+            var fieldId = Guid.NewGuid();
+
+            var filters = new List<JobFieldFilter>
+        {
+            new() { FieldId = fieldId, ValueMask = "   ", IsInverse = false }
+        };
+
+            // Act
+            var result = await _sut.MatchAsync(unitIds, filters);
+
+            // Assert
+            Assert.Equal(unitIds.Count, result.Count);
+            _fieldValueRepoMock.Verify(
+                r => r.FindValueIdsByMaskAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()),
+                Times.Never);
+        }
+
+        /// <summary>
+        /// Если после одного из фильтров набор стал пустым,
+        /// последующие фильтры не выполняются.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_EarlyBreak_WhenNoUnitsLeft()
+        {
+            // Arrange
+            var unit1 = Guid.NewGuid();
+            var unitIds = new List<Guid> { unit1 };
+
+            var fieldId1 = Guid.NewGuid();
+            var fieldId2 = Guid.NewGuid();
+            var valueId1 = Guid.NewGuid();
+
+            var filters = new List<JobFieldFilter>
+        {
+            new() { FieldId = fieldId1, ValueMask = "СХД", IsInverse = false },
+            new() { FieldId = fieldId2, ValueMask = "коммутатор", IsInverse = false }
+        };
+
+            // Первый фильтр возвращает пустой результат
+            _fieldValueRepoMock
+                .Setup(r => r.FindValueIdsByMaskAsync("СХД", It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid> { valueId1 });
+            _unitRepoMock
+                .Setup(r => r.FindUnitIdsByValueIdsAsync(
+                    It.IsAny<IReadOnlyList<Guid>>(),
+                    fieldId1,
+                    It.IsAny<IReadOnlyList<Guid>>(),
+                    It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<Guid>());
+
+            // Act
+            var result = await _sut.MatchAsync(unitIds, filters);
+
+            // Assert
+            Assert.Empty(result);
+
+            // Второй фильтр не должен вызываться
+            _fieldValueRepoMock.Verify(
+                r => r.FindValueIdsByMaskAsync("коммутатор", It.IsAny<CancellationToken>()),
+                Times.Never);
+        }
+    }
+}

PARR.DAL.Tests/Services/UnitFilterService/Matchers/UnitRelationshipMatcherTests.cs

@@ -0,0 +1,591 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using PARR.Core.Repositories.Interfaces.Unit;
+using PARR.Core.Services.UnitFilterService.Matchers;
+using PARR.DAL.Context;
+using PARR.Domain.Entities.JobEntities;
+using PARR.Domain.Entities.Unit;
+
+namespace PARR.Core.Tests.Services.UnitFilterService.Matchers
+{
+    public class UnitRelationshipMatcherTests
+    {
+        private readonly Mock<IUnitInUnitRepository> _unitInUnitRepoMock;
+        private readonly Mock<IUnitInValueRepository> _unitInValueRepoMock;
+        private readonly UnitRelationshipMatcher _sut;
+
+        public UnitRelationshipMatcherTests()
+        {
+            _unitInUnitRepoMock = new Mock<IUnitInUnitRepository>();
+            _unitInValueRepoMock = new Mock<IUnitInValueRepository>();
+            var logger = NullLoggerFactory.Instance.CreateLogger<UnitRelationshipMatcher>();
+            _sut = new UnitRelationshipMatcher(
+                _unitInUnitRepoMock.Object,
+                _unitInValueRepoMock.Object,
+                logger);
+        }
+
+        /// <summary>
+        /// Создаёт юнит со значением поля и добавляет его в контекст.
+        /// </summary>
+        private static Unit BuildUnit(Guid id, string name, Guid fieldId, string fieldValue)
+        {
+            var fieldVal = new UnitFieldValue { Id = Guid.NewGuid(), Value = fieldValue };
+            return new Unit
+            {
+                Id = id,
+                Name = name,
+                UnitValues = new List<UnitInValue>
+            {
+                new UnitInValue
+                {
+                    UnitId = id,
+                    FieldId = fieldId,
+                    ValueId = fieldVal.Id,
+                    Value = fieldVal
+                }
+            }
+            };
+        }
+
+        /// <summary>
+        /// Настраивает моки репозиториев для работы с InMemory-контекстом.
+        /// GetMatchingTargetIds эмулирует ILike через Contains с обрезкой символов '%'.
+        /// </summary>
+        private void SetupMocks(DataContext context)
+        {
+            _unitInUnitRepoMock
+                .Setup(r => r.Get())
+                .Returns(context.UnitInUnits.AsQueryable());
+
+            _unitInValueRepoMock
+                .Setup(r => r.GetMatchingTargetIds(It.IsAny<Guid>(), It.IsAny<string>()))
+                .Returns((Guid fieldId, string mask) =>
+                {
+                    var trimmed = mask.Trim('%');
+                    return context.UnitInValues
+                        .AsNoTracking()
+                        .Where(uv => uv.FieldId == fieldId
+                                     && uv.Value != null
+                                     && uv.Value.Value != null
+                                     && uv.Value.Value.Contains(trimmed, StringComparison.OrdinalIgnoreCase))
+                        .Select(uv => uv.UnitId)
+                        .Distinct()
+                        .AsQueryable();
+                });
+        }
+
+        /// <summary>
+        /// Если фильтры не заданы, все юниты возвращаются как контексты без изменений.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_NoFilters_ReturnsAllUnitsAsContexts()
+        {
+            // Arrange
+            var unit1 = Guid.NewGuid();
+            var unit2 = Guid.NewGuid();
+            var unitIds = new List<Guid> { unit1, unit2 };
+
+            // Act
+            var result = await _sut.MatchAsync(unitIds, Enumerable.Empty<JobRelationshipFilter>());
+
+            // Assert
+            Assert.Equal(2, result.Count);
+            Assert.Contains(result, c => c.UnitId == unit1);
+            Assert.Contains(result, c => c.UnitId == unit2);
+        }
+
+        /// <summary>
+        /// Если входной набор пуст, возвращается пустой список.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_EmptyUnitIds_ReturnsEmpty()
+        {
+            // Arrange
+            var filters = new List<JobRelationshipFilter>
+        {
+            new() { FieldId = Guid.NewGuid(), ValueMask = "%test%", IsParent = true }
+        };
+
+            // Act
+            var result = await _sut.MatchAsync(new List<Guid>(), filters);
+
+            // Assert
+            Assert.Empty(result);
+        }
+
+        /// <summary>
+        /// Прямой родительский фильтр (IsFullMatch=false):
+        /// юнит проходит, если ХОТЯ БЫ ОДИН из его родителей соответствует маске.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_ParentFilter_DirectAnyMatch_OnlyUnitsWithMatchingParentPass()
+        {
+            // Arrange
+            var dbOptions = new DbContextOptionsBuilder<DataContext>()
+                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+                .Options;
+            using var context = new DataContext(dbOptions);
+
+            var fieldId = Guid.NewGuid();
+            var parentGood = Guid.NewGuid();
+            var parentBad = Guid.NewGuid();
+            var unitWithGoodParent = Guid.NewGuid();
+            var unitWithBadParent = Guid.NewGuid();
+
+            context.Units.AddRange(
+                BuildUnit(parentGood, "Parent_Good", fieldId, "VALID-TAG"),
+                BuildUnit(parentBad, "Parent_Bad", fieldId, "OTHER-TAG"),
+                BuildUnit(unitWithGoodParent, "Unit_Good", Guid.NewGuid(), "x"),
+                BuildUnit(unitWithBadParent, "Unit_Bad", Guid.NewGuid(), "x")
+            );
+
+            context.UnitInUnits.AddRange(
+                new UnitInUnit { ParentUnitId = parentGood, ChildUnitId = unitWithGoodParent, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = parentBad, ChildUnitId = unitWithBadParent, DateCreated = DateTimeOffset.UtcNow }
+            );
+
+            await context.SaveChangesAsync();
+            SetupMocks(context);
+
+            var filters = new List<JobRelationshipFilter>
+        {
+            new()
+            {
+                FieldId = fieldId,
+                ValueMask = "%VALID%",
+                IsParent = true,
+                IsInverse = false,
+                IsFullMatch = false
+            }
+        };
+
+            // Act
+            var result = await _sut.MatchAsync(
+                new List<Guid> { unitWithGoodParent, unitWithBadParent }, filters);
+
+            // Assert
+            var resultIds = result.Select(c => c.UnitId).ToList();
+            Assert.Contains(unitWithGoodParent, resultIds);
+            Assert.DoesNotContain(unitWithBadParent, resultIds);
+
+            var ctx = result.First(c => c.UnitId == unitWithGoodParent);
+            Assert.Contains(parentGood, ctx.ValidParentIds);
+        }
+
+        /// <summary>
+        /// Инверсный родительский фильтр (IsInverse=true, IsFullMatch=false):
+        /// юнит проходит, если ХОТЯ БЫ ОДИН родитель НЕ соответствует маске.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_ParentFilter_Inverse_UnitsWithOnlyForbiddenParentsExcluded()
+        {
+            // Arrange
+            var dbOptions = new DbContextOptionsBuilder<DataContext>()
+                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+                .Options;
+            using var context = new DataContext(dbOptions);
+
+            var fieldId = Guid.NewGuid();
+            var parentForbidden = Guid.NewGuid();
+            var parentClean = Guid.NewGuid();
+            var unitWithForbiddenOnly = Guid.NewGuid();
+            var unitWithCleanParent = Guid.NewGuid();
+
+            context.Units.AddRange(
+                BuildUnit(parentForbidden, "Parent_Forbidden", fieldId, "FORBIDDEN"),
+                BuildUnit(parentClean, "Parent_Clean", fieldId, "CLEAN"),
+                BuildUnit(unitWithForbiddenOnly, "Unit_Forbidden", Guid.NewGuid(), "x"),
+                BuildUnit(unitWithCleanParent, "Unit_Clean", Guid.NewGuid(), "x")
+            );
+
+            context.UnitInUnits.AddRange(
+                new UnitInUnit { ParentUnitId = parentForbidden, ChildUnitId = unitWithForbiddenOnly, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = parentClean, ChildUnitId = unitWithCleanParent, DateCreated = DateTimeOffset.UtcNow }
+            );
+
+            await context.SaveChangesAsync();
+            SetupMocks(context);
+
+            var filters = new List<JobRelationshipFilter>
+        {
+            new()
+            {
+                FieldId = fieldId,
+                ValueMask = "%FORBIDDEN%",
+                IsParent = true,
+                IsInverse = true,
+                IsFullMatch = false
+            }
+        };
+
+            // Act
+            var result = await _sut.MatchAsync(
+                new List<Guid> { unitWithForbiddenOnly, unitWithCleanParent }, filters);
+
+            // Assert
+            var resultIds = result.Select(c => c.UnitId).ToList();
+            Assert.Contains(unitWithCleanParent, resultIds);
+            Assert.DoesNotContain(unitWithForbiddenOnly, resultIds);
+        }
+
+        /// <summary>
+        /// IsFullMatch=true: юнит проходит, только если ВСЕ его родители соответствуют маске.
+        /// Юнит с одним "плохим" родителем исключается.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_ParentFilter_IsFullMatch_AllParentsMustPass()
+        {
+            // Arrange
+            var dbOptions = new DbContextOptionsBuilder<DataContext>()
+                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+                .Options;
+            using var context = new DataContext(dbOptions);
+
+            var fieldId = Guid.NewGuid();
+            var parentGood1 = Guid.NewGuid();
+            var parentGood2 = Guid.NewGuid();
+            var parentBad = Guid.NewGuid();
+            var unitAllGood = Guid.NewGuid();
+            var unitMixed = Guid.NewGuid();
+
+            context.Units.AddRange(
+                BuildUnit(parentGood1, "Parent_Good1", fieldId, "Good"),
+                BuildUnit(parentGood2, "Parent_Good2", fieldId, "Good"),
+                BuildUnit(parentBad, "Parent_Bad", fieldId, "Bad"),
+                BuildUnit(unitAllGood, "Unit_AllGood", Guid.NewGuid(), "x"),
+                BuildUnit(unitMixed, "Unit_Mixed", Guid.NewGuid(), "x")
+            );
+
+            context.UnitInUnits.AddRange(
+                new UnitInUnit { ParentUnitId = parentGood1, ChildUnitId = unitAllGood, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = parentGood2, ChildUnitId = unitAllGood, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = parentGood1, ChildUnitId = unitMixed, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = parentBad, ChildUnitId = unitMixed, DateCreated = DateTimeOffset.UtcNow }
+            );
+
+            await context.SaveChangesAsync();
+            SetupMocks(context);
+
+            var filters = new List<JobRelationshipFilter>
+        {
+            new()
+            {
+                FieldId = fieldId,
+                ValueMask = "%Good%",
+                IsParent = true,
+                IsInverse = false,
+                IsFullMatch = true
+            }
+        };
+
+            // Act
+            var result = await _sut.MatchAsync(
+                new List<Guid> { unitAllGood, unitMixed }, filters);
+
+            // Assert
+            var resultIds = result.Select(c => c.UnitId).ToList();
+            Assert.Contains(unitAllGood, resultIds);
+            Assert.DoesNotContain(unitMixed, resultIds);
+        }
+
+        /// <summary>
+        /// Комбинация IsInverse=true и IsFullMatch=true:
+        /// юнит проходит, только если НИ ОДИН родитель не соответствует маске.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_ParentFilter_InverseAndFullMatch_UnitWithAnyForbiddenParentExcluded()
+        {
+            // Arrange
+            var dbOptions = new DbContextOptionsBuilder<DataContext>()
+                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+                .Options;
+            using var context = new DataContext(dbOptions);
+
+            var fieldId = Guid.NewGuid();
+            var parentForbidden = Guid.NewGuid();
+            var parentClean = Guid.NewGuid();
+            var unitMixed = Guid.NewGuid();
+            var unitAllClean = Guid.NewGuid();
+
+            context.Units.AddRange(
+                BuildUnit(parentForbidden, "Parent_Forbidden", fieldId, "FORBIDDEN"),
+                BuildUnit(parentClean, "Parent_Clean", fieldId, "CLEAN"),
+                BuildUnit(unitMixed, "Unit_Mixed", Guid.NewGuid(), "x"),
+                BuildUnit(unitAllClean, "Unit_AllClean", Guid.NewGuid(), "x")
+            );
+
+            context.UnitInUnits.AddRange(
+                new UnitInUnit { ParentUnitId = parentForbidden, ChildUnitId = unitMixed, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = parentClean, ChildUnitId = unitMixed, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = parentClean, ChildUnitId = unitAllClean, DateCreated = DateTimeOffset.UtcNow }
+            );
+
+            await context.SaveChangesAsync();
+            SetupMocks(context);
+
+            var filters = new List<JobRelationshipFilter>
+        {
+            new()
+            {
+                FieldId = fieldId,
+                ValueMask = "%FORBIDDEN%",
+                IsParent = true,
+                IsInverse = true,
+                IsFullMatch = true
+            }
+        };
+
+            // Act
+            var result = await _sut.MatchAsync(
+                new List<Guid> { unitMixed, unitAllClean }, filters);
+
+            // Assert
+            var resultIds = result.Select(c => c.UnitId).ToList();
+            Assert.Contains(unitAllClean, resultIds);
+            Assert.DoesNotContain(unitMixed, resultIds);
+        }
+
+        /// <summary>
+        /// Дочерний фильтр (IsParent=false):
+        /// юнит проходит, если хотя бы один из его детей соответствует маске.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_ChildFilter_DirectMatch()
+        {
+            // Arrange
+            var dbOptions = new DbContextOptionsBuilder<DataContext>()
+                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+                .Options;
+            using var context = new DataContext(dbOptions);
+
+            var fieldId = Guid.NewGuid();
+            var childValid = Guid.NewGuid();
+            var childInvalid = Guid.NewGuid();
+            var parentWithValidChild = Guid.NewGuid();
+            var parentWithInvalidChild = Guid.NewGuid();
+
+            context.Units.AddRange(
+                BuildUnit(childValid, "Child_Valid", fieldId, "VALID"),
+                BuildUnit(childInvalid, "Child_Invalid", fieldId, "OTHER"),
+                BuildUnit(parentWithValidChild, "Parent_Valid", Guid.NewGuid(), "x"),
+                BuildUnit(parentWithInvalidChild, "Parent_Invalid", Guid.NewGuid(), "x")
+            );
+
+            context.UnitInUnits.AddRange(
+                new UnitInUnit { ParentUnitId = parentWithValidChild, ChildUnitId = childValid, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = parentWithInvalidChild, ChildUnitId = childInvalid, DateCreated = DateTimeOffset.UtcNow }
+            );
+
+            await context.SaveChangesAsync();
+            SetupMocks(context);
+
+            var filters = new List<JobRelationshipFilter>
+        {
+            new()
+            {
+                FieldId = fieldId,
+                ValueMask = "%VALID%",
+                IsParent = false,
+                IsInverse = false,
+                IsFullMatch = false
+            }
+        };
+
+            // Act
+            var result = await _sut.MatchAsync(
+                new List<Guid> { parentWithValidChild, parentWithInvalidChild }, filters);
+
+            // Assert
+            var resultIds = result.Select(c => c.UnitId).ToList();
+            Assert.Contains(parentWithValidChild, resultIds);
+            Assert.DoesNotContain(parentWithInvalidChild, resultIds);
+
+            var ctx = result.First(c => c.UnitId == parentWithValidChild);
+            Assert.Contains(childValid, ctx.ValidChildIds);
+        }
+
+        /// <summary>
+        /// Юнит без связей исключается, если есть фильтры с непустой маской.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_UnitWithoutRelatedUnits_IsExcluded()
+        {
+            // Arrange
+            var dbOptions = new DbContextOptionsBuilder<DataContext>()
+                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+                .Options;
+            using var context = new DataContext(dbOptions);
+
+            var fieldId = Guid.NewGuid();
+            var unitWithParent = Guid.NewGuid();
+            var unitOrphan = Guid.NewGuid();
+            var parent = Guid.NewGuid();
+
+            context.Units.AddRange(
+                BuildUnit(parent, "Parent", fieldId, "VALID"),
+                BuildUnit(unitWithParent, "Unit_WithParent", Guid.NewGuid(), "x"),
+                BuildUnit(unitOrphan, "Unit_Orphan", Guid.NewGuid(), "x")
+            );
+
+            context.UnitInUnits.AddRange(
+                new UnitInUnit { ParentUnitId = parent, ChildUnitId = unitWithParent, DateCreated = DateTimeOffset.UtcNow }
+            );
+
+            await context.SaveChangesAsync();
+            SetupMocks(context);
+
+            var filters = new List<JobRelationshipFilter>
+        {
+            new()
+            {
+                FieldId = fieldId,
+                ValueMask = "%VALID%",
+                IsParent = true,
+                IsInverse = false,
+                IsFullMatch = false
+            }
+        };
+
+            // Act
+            var result = await _sut.MatchAsync(
+                new List<Guid> { unitWithParent, unitOrphan }, filters);
+
+            // Assert
+            var resultIds = result.Select(c => c.UnitId).ToList();
+            Assert.Contains(unitWithParent, resultIds);
+            Assert.DoesNotContain(unitOrphan, resultIds);
+        }
+
+        /// <summary>
+        /// Фильтр с пустой маской пропускается: юниты не исключаются.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_EmptyMask_FilterSkipped()
+        {
+            // Arrange
+            var dbOptions = new DbContextOptionsBuilder<DataContext>()
+                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+                .Options;
+            using var context = new DataContext(dbOptions);
+
+            var fieldId = Guid.NewGuid();
+            var unit1 = Guid.NewGuid();
+            var parent = Guid.NewGuid();
+
+            context.Units.AddRange(
+                BuildUnit(parent, "Parent", fieldId, "Any"),
+                BuildUnit(unit1, "Unit", Guid.NewGuid(), "x")
+            );
+
+            context.UnitInUnits.AddRange(
+                new UnitInUnit { ParentUnitId = parent, ChildUnitId = unit1, DateCreated = DateTimeOffset.UtcNow }
+            );
+
+            await context.SaveChangesAsync();
+            SetupMocks(context);
+
+            var filters = new List<JobRelationshipFilter>
+        {
+            new()
+            {
+                FieldId = fieldId,
+                ValueMask = "   ",
+                IsParent = true,
+                IsInverse = false,
+                IsFullMatch = false
+            }
+        };
+
+            // Act
+            var result = await _sut.MatchAsync(new List<Guid> { unit1 }, filters);
+
+            // Assert
+            Assert.Single(result);
+            Assert.Equal(unit1, result.First().UnitId);
+        }
+
+        /// <summary>
+        /// Комбинация родительского и дочернего фильтров:
+        /// юнит должен пройти оба направления.
+        /// </summary>
+        [Fact]
+        public async Task MatchAsync_CombinedParentAndChildFilters_BothDirectionsApplied()
+        {
+            // Arrange
+            var dbOptions = new DbContextOptionsBuilder<DataContext>()
+                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+                .Options;
+            using var context = new DataContext(dbOptions);
+
+            var parentFieldId = Guid.NewGuid();
+            var childFieldId = Guid.NewGuid();
+
+            var goodParent = Guid.NewGuid();
+            var badParent = Guid.NewGuid();
+            var goodChild = Guid.NewGuid();
+            var badChild = Guid.NewGuid();
+
+            var unitAllGood = Guid.NewGuid();
+            var unitBadParent = Guid.NewGuid();
+            var unitBadChild = Guid.NewGuid();
+
+            context.Units.AddRange(
+                BuildUnit(goodParent, "GoodParent", parentFieldId, "GOOD-PARENT"),
+                BuildUnit(badParent, "BadParent", parentFieldId, "BAD-PARENT"),
+                BuildUnit(goodChild, "GoodChild", childFieldId, "GOOD-CHILD"),
+                BuildUnit(badChild, "BadChild", childFieldId, "BAD-CHILD"),
+                BuildUnit(unitAllGood, "Unit_AllGood", Guid.NewGuid(), "x"),
+                BuildUnit(unitBadParent, "Unit_BadParent", Guid.NewGuid(), "x"),
+                BuildUnit(unitBadChild, "Unit_BadChild", Guid.NewGuid(), "x")
+            );
+
+            context.UnitInUnits.AddRange(
+                // unitAllGood: хороший родитель + хороший ребёнок
+                new UnitInUnit { ParentUnitId = goodParent, ChildUnitId = unitAllGood, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = unitAllGood, ChildUnitId = goodChild, DateCreated = DateTimeOffset.UtcNow },
+                // unitBadParent: плохой родитель + хороший ребёнок
+                new UnitInUnit { ParentUnitId = badParent, ChildUnitId = unitBadParent, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = unitBadParent, ChildUnitId = goodChild, DateCreated = DateTimeOffset.UtcNow },
+                // unitBadChild: хороший родитель + плохой ребёнок
+                new UnitInUnit { ParentUnitId = goodParent, ChildUnitId = unitBadChild, DateCreated = DateTimeOffset.UtcNow },
+                new UnitInUnit { ParentUnitId = unitBadChild, ChildUnitId = badChild, DateCreated = DateTimeOffset.UtcNow }
+            );
+
+            await context.SaveChangesAsync();
+            SetupMocks(context);
+
+            var filters = new List<JobRelationshipFilter>
+        {
+            new()
+            {
+                FieldId = parentFieldId,
+                ValueMask = "%GOOD-PARENT%",
+                IsParent = true,
+                IsInverse = false,
+                IsFullMatch = false
+            },
+            new()
+            {
+                FieldId = childFieldId,
+                ValueMask = "%GOOD-CHILD%",
+                IsParent = false,
+                IsInverse = false,
+                IsFullMatch = false
+            }
+        };
+
+            // Act
+            var result = await _sut.MatchAsync(
+                new List<Guid> { unitAllGood, unitBadParent, unitBadChild }, filters);
+
+            // Assert
+            var resultIds = result.Select(c => c.UnitId).ToList();
+            Assert.Contains(unitAllGood, resultIds);
+            Assert.DoesNotContain(unitBadParent, resultIds);
+            Assert.DoesNotContain(unitBadChild, resultIds);
+        }
+    }
+}

PARR.DAL.Tests/Services/UnitFilterService/UnitFilterServiceTests.cs

@@ -21,14 +21,6 @@ public class UnitFilterServiceTests
 {
     #region Helpers
 
-    /// <summary>
-    /// Создаёт тестовую сущность Unit с заданным значением поля.
-    /// Используется для подготовки данных в тестах фильтрации.
-    /// </summary>
-    /// <param name="id">Уникальный идентификатор юнита</param>
-    /// <param name="name">Имя юнита для отладки</param>
-    /// <param name="fieldId">Идентификатор поля, к которому привязывается значение</param>
-    /// <param name="fieldValue">Значение поля</param>
     private static Unit BuildTestUnit(Guid id, string name, Guid fieldId, string fieldValue)
     {
         var fieldVal = new UnitFieldValue { Id = Guid.NewGuid(), Value = fieldValue };
@@ -49,10 +41,6 @@ public class UnitFilterServiceTests
         };
     }
 
-    /// <summary>
-    /// Создаёт тестовый объект JobGroupType с кодом Umbrella.
-    /// Используется для тестирования логики групповых работ типа "зонтик".
-    /// </summary>
     private static JobGroupType BuildTestJobGroupType() => new()
     {
         Id = Guid.NewGuid(),
@@ -61,10 +49,6 @@ public class UnitFilterServiceTests
         Description = "Test"
     };
 
-    /// <summary>
-    /// Создаёт тестовый объект JobGroup с заполненными обязательными полями.
-    /// Используется для подготовки навигационных свойств в тестах.
-    /// </summary>
     private static JobGroup BuildTestJobGroup() => new()
     {
         Id = Guid.NewGuid(),
@@ -79,20 +63,12 @@ public class UnitFilterServiceTests
         GroupType = BuildTestJobGroupType()
     };
 
-    /// <summary>
-    /// Создаёт тестовый объект JobAutoControl с отключённым автоконтролем.
-    /// Используется для заполнения обязательного свойства в сущности Job.
-    /// </summary>
     private static JobAutoControl BuildTestAutoControl(Guid jobId) => new()
     {
         JobId = jobId,
         IsEnable = false
     };
 
-    /// <summary>
-    /// Контейнер для моков репозиториев.
-    /// Упрощает передачу зависимостей в метод создания сервиса.
-    /// </summary>
     private class RepositoryMocks
     {
         public Mock<IUnitRepository> Unit { get; set; }
@@ -101,7 +77,6 @@ public class UnitFilterServiceTests
         public Mock<IUnitFieldRepository> UnitField { get; set; }
         public Mock<IJobRepository> Job { get; set; }
         public Mock<IRedisCacheService> Cache { get; set; }
-        // Новые зависимости после рефакторинга
         public Mock<IUnitService> UnitService { get; set; }
         public Mock<IUnitFieldMatcher> FieldMatcher { get; set; }
         public Mock<IUnitRelationshipMatcher> RelationshipMatcher { get; set; }
@@ -110,11 +85,6 @@ public class UnitFilterServiceTests
         public Mock<IUnitNameResolver> NameResolver { get; set; }
     }
 
-    /// <summary>
-    /// Настраивает базовые моки репозиториев с использованием InMemory-контекста.
-    /// Возвращает объект с подготовленными моками для повторного использования в тестах.
-    /// </summary>
-    /// <param name="context">Экземпляр DataContext с тестовыми данными</param>
     private static RepositoryMocks ArrangeRepositoryMocks(DataContext context)
     {
         var unitRepoMock = new Mock<IUnitRepository>();
@@ -126,16 +96,6 @@ public class UnitFilterServiceTests
         unitInUnitRepoMock.Setup(r => r.Get()).Returns(context.UnitInUnits.AsQueryable());
 
         var unitInValueRepoMock = new Mock<IUnitInValueRepository>();
-        // Единый подход: используем контекст для поддержки IAsyncQueryProvider
-        // Это гарантирует корректную работу .ToListAsync() внутри сервиса
-        unitInValueRepoMock.Setup(r => r.GetMatchingTargetIds(It.IsAny<Guid>(), It.IsAny<string>()))
-                           .Returns((Guid fId, string mask) =>
-                               context.UnitInValues
-                               .AsNoTracking()
-                               .Where(uv => uv.FieldId == fId && uv.Value != null)
-                               .Select(uv => uv.UnitId)
-                               .Distinct()
-                               .AsQueryable());
 
         var unitFieldRepoMock = new Mock<IUnitFieldRepository>();
         unitFieldRepoMock.Setup(r => r.Get()).Returns(new List<UnitField>().AsQueryable());
@@ -154,46 +114,60 @@ public class UnitFilterServiceTests
         var resultLoaderMock = new Mock<IUnitFilterResultLoader>();
         var nameResolverMock = new Mock<IUnitNameResolver>();
 
-        // Настройка NameResolver: возвращаем все ID юнитов из контекста (эмуляция кэш-промаха + БД)
         nameResolverMock.Setup(r => r.ResolveAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
                         .ReturnsAsync((string mask, CancellationToken ct) =>
                             context.Units.Select(u => u.Id).ToList());
 
-        // Настройка FieldMatcher: эмуляция SQL-фильтрации через InMemory-контекст
-        fieldMatcherMock.Setup(r => r.MatchAsync(It.IsAny<IReadOnlyList<Guid>>(), It.IsAny<IEnumerable<JobFieldFilter>>(), It.IsAny<CancellationToken>()))
+        // По умолчанию FieldMatcher пропускает все юниты без изменений.
+        // В конкретных тестах переопределяется для эмуляции фильтрации.
+        fieldMatcherMock.Setup(r => r.MatchAsync(
+                            It.IsAny<IReadOnlyList<Guid>>(),
+                            It.IsAny<IEnumerable<JobFieldFilter>>(),
+                            It.IsAny<CancellationToken>()))
                         .ReturnsAsync((IReadOnlyList<Guid> ids, IEnumerable<JobFieldFilter> filters, CancellationToken ct) =>
                             ids.ToList());
 
-        // Настройка RelationshipMatcher: возвращаем контексты без изменений
-        relationshipMatcherMock.Setup(r => r.MatchAsync(It.IsAny<IReadOnlyList<Guid>>(), It.IsAny<IEnumerable<JobRelationshipFilter>>(), It.IsAny<CancellationToken>()))
+        // По умолчанию RelationshipMatcher возвращает контексты без изменений.
+        // В конкретных тестах переопределяется для эмуляции фильтрации связей.
+        relationshipMatcherMock.Setup(r => r.MatchAsync(
+                                    It.IsAny<IReadOnlyList<Guid>>(),
+                                    It.IsAny<IEnumerable<JobRelationshipFilter>>(),
+                                    It.IsAny<CancellationToken>()))
                                .ReturnsAsync((IReadOnlyList<Guid> ids, IEnumerable<JobRelationshipFilter> filters, CancellationToken ct) =>
-                                   ids.Select(id => new UnitFilterMatchResult { UnitId = id }).ToList());
+                                   ids.Select(id => new UnitFilterMatchResult
+                                   {
+                                       UnitId = id,
+                                       ValidParentIds = new HashSet<Guid>(),
+                                       ValidChildIds = new HashSet<Guid>()
+                                   }).ToList());
 
-        // Настройка UmbrellaFilter: пропускаем без изменений
         umbrellaFilterMock.Setup(r => r.Apply(It.IsAny<List<UnitFilterMatchResult>>(), It.IsAny<Job>()))
                           .Returns((List<UnitFilterMatchResult> ctx, Job j) => ctx);
 
-        // Настройка ResultLoader: формируем DTO из контекста
         resultLoaderMock.Setup(r => r.LoadAsync(It.IsAny<List<UnitFilterMatchResult>>(), It.IsAny<CancellationToken>()))
                         .ReturnsAsync((List<UnitFilterMatchResult> contexts, CancellationToken ct) =>
                         {
                             var unitIds = contexts.Select(c => c.UnitId).ToHashSet();
                             var units = context.Units.Where(u => unitIds.Contains(u.Id)).ToList();
-                            return units.Select(u => new UnitFilterResultDto
+                            return units.Select(u =>
                             {
-                                Id = u.Id,
-                                Name = u.Name,
-                                Values = u.UnitValues?.Select(v => new UnitValueDto
+                                var ctx = contexts.First(c => c.UnitId == u.Id);
+                                return new UnitFilterResultDto
                                 {
-                                    FieldId = v.FieldId,
-                                    Value = v.Value?.Value
-                                }).ToList() ?? new List<UnitValueDto>(),
-                                Parents = contexts.First(c => c.UnitId == u.Id).ValidParentIds
-                                    .Select(pid => new RelatedUnitDto { UnitId = pid })
-                                    .ToList(),
-                                Children = contexts.First(c => c.UnitId == u.Id).ValidChildIds
-                                    .Select(cid => new RelatedUnitDto { UnitId = cid })
-                                    .ToList()
+                                    Id = u.Id,
+                                    Name = u.Name,
+                                    Values = u.UnitValues?.Select(v => new UnitValueDto
+                                    {
+                                        FieldId = v.FieldId,
+                                        Value = v.Value?.Value
+                                    }).ToList() ?? new List<UnitValueDto>(),
+                                    Parents = (ctx.ValidParentIds ?? new HashSet<Guid>())
+                                        .Select(pid => new RelatedUnitDto { UnitId = pid })
+                                        .ToList(),
+                                    Children = (ctx.ValidChildIds ?? new HashSet<Guid>())
+                                        .Select(cid => new RelatedUnitDto { UnitId = cid })
+                                        .ToList()
+                                };
                             }).ToList();
                         });
 
@@ -214,12 +188,6 @@ public class UnitFilterServiceTests
         };
     }
 
-    /// <summary>
-    /// Создаёт экземпляр тестируемого сервиса (SUT — System Under Test).
-    /// Инкапсулирует логику конструктора для упрощения тестов.
-    /// </summary>
-    /// <param name="mocks">Подготовленные моки репозиториев</param>
-    /// <param name="logger">Экземпляр логгера для сервиса</param>
     private static Core.Services.UnitFilterService.UnitFilterService CreateSut(
         RepositoryMocks mocks,
         ILogger<Core.Services.UnitFilterService.UnitFilterService> logger)
@@ -245,8 +213,9 @@ public class UnitFilterServiceTests
 
 
     /// <summary>
-    /// Проверяет, что юниты, не прошедшие фильтрацию по полю (FieldFilter) 
-    /// или по связям (RelationshipFilter), корректно исключаются из результата.
+    /// Проверяет, что юниты, не прошедшие фильтрацию по полю или по связям,
+    /// корректно исключаются из результата.
+    /// Логика фильтрации эмулируется через моки FieldMatcher и RelationshipMatcher.
     /// </summary>
     [Fact]
     public async Task GetUnitsByJobFilterAsync_UnitsWithInvalidFieldOrRelationshipValue_AreExcluded()
@@ -260,30 +229,24 @@ public class UnitFilterServiceTests
         var jobId = Guid.NewGuid();
         var fieldId = Guid.NewGuid();
         var validParentId = Guid.NewGuid();
-        var wrongParentId = Guid.NewGuid();
 
         var unitPassesAll = Guid.NewGuid();
         var unitFailsFieldFilter = Guid.NewGuid();
         var unitFailsRelationshipFilter = Guid.NewGuid();
 
-        // Подготовка тестовых данных: юниты
         context.Units.AddRange(
             BuildTestUnit(unitPassesAll, "Unit_PassesAll", fieldId, "Accepted Value"),
             BuildTestUnit(unitFailsFieldFilter, "Unit_FailsField", fieldId, "Rejected Value"),
             BuildTestUnit(unitFailsRelationshipFilter, "Unit_FailsRel", fieldId, "Accepted Value"),
-            BuildTestUnit(validParentId, "Parent_Valid", fieldId, "Valid Parent"),
-            BuildTestUnit(wrongParentId, "Parent_Wrong", fieldId, "Wrong Parent")
+            BuildTestUnit(validParentId, "Parent_Valid", fieldId, "Valid Parent")
         );
 
-        // Подготовка тестовых данных: связи между юнитами
         context.UnitInUnits.AddRange(
-            new UnitInUnit { ParentUnitId = validParentId, ChildUnitId = unitPassesAll, DateCreated = DateTimeOffset.UtcNow },
-            new UnitInUnit { ParentUnitId = wrongParentId, ChildUnitId = unitFailsRelationshipFilter, DateCreated = DateTimeOffset.UtcNow }
+            new UnitInUnit { ParentUnitId = validParentId, ChildUnitId = unitPassesAll, DateCreated = DateTimeOffset.UtcNow }
         );
 
         await context.SaveChangesAsync();
 
-        // Формируем тестовый объект Job с фильтрами
         var job = new Job
         {
             Id = jobId,
@@ -318,20 +281,29 @@ public class UnitFilterServiceTests
             }
         };
 
-        // Настройка моков репозиториев
         var mocks = ArrangeRepositoryMocks(context);
 
-        // Переопределяем мок фильтрации по полю: в реальном коде используется EF.Functions.ILike,
-        // в тесте заменяем на прямое сравнение строк для предсказуемости
-        mocks.Unit.Setup(r => r.GetUnitByFieldAndValue(It.IsAny<IQueryable<Unit>>(), It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<bool>()))
-                    .Returns((IQueryable<Unit> q, Guid fId, string mask, bool inv) =>
-                        q.Where(u => u.UnitValues != null && u.UnitValues.Any(v => v.FieldId == fId && v.Value != null && v.Value.Value == "Accepted Value")));
+        // Эмуляция FieldMatcher: пропускает только юниты со значением "Accepted Value"
+        mocks.FieldMatcher.Setup(r => r.MatchAsync(
+                            It.IsAny<IReadOnlyList<Guid>>(),
+                            It.IsAny<IEnumerable<JobFieldFilter>>(),
+                            It.IsAny<CancellationToken>()))
+                        .ReturnsAsync((IReadOnlyList<Guid> ids, IEnumerable<JobFieldFilter> filters, CancellationToken ct) =>
+                            ids.Where(id => id == unitPassesAll || id == unitFailsRelationshipFilter).ToList());
 
-        // ИСПРАВЛЕНО: используем запрос к контексту вместо массива.
-        // Массивный AsQueryable() не поддерживает IAsyncQueryProvider, что вызывает крах при вызове .ToListAsync() внутри сервиса.
-        // Запрос к InMemory DbSet гарантирует корректную асинхронную материализацию.
-        mocks.UnitInValue.Setup(r => r.GetMatchingTargetIds(fieldId, It.IsAny<string>()))
-                         .Returns(context.Units.Where(u => u.Id == validParentId).Select(u => u.Id).AsQueryable());
+        // Эмуляция RelationshipMatcher: пропускает только unitPassesAll
+        mocks.RelationshipMatcher.Setup(r => r.MatchAsync(
+                                    It.IsAny<IReadOnlyList<Guid>>(),
+                                    It.IsAny<IEnumerable<JobRelationshipFilter>>(),
+                                    It.IsAny<CancellationToken>()))
+                               .ReturnsAsync((IReadOnlyList<Guid> ids, IEnumerable<JobRelationshipFilter> filters, CancellationToken ct) =>
+                                   ids.Where(id => id == unitPassesAll)
+                                      .Select(id => new UnitFilterMatchResult
+                                      {
+                                          UnitId = id,
+                                          ValidParentIds = new HashSet<Guid> { validParentId },
+                                          ValidChildIds = new HashSet<Guid>()
+                                      }).ToList());
 
         var logger = NullLoggerFactory.Instance.CreateLogger<Core.Services.UnitFilterService.UnitFilterService>();
         var service = CreateSut(mocks, logger);
@@ -354,8 +326,8 @@ public class UnitFilterServiceTests
     }
 
     /// <summary>
-    /// Проверяет, что юниты исключаются, если их единственный родительский юнит 
-    /// содержит запрещённое значение тега (сценарий с IsInverse = true).
+    /// Проверяет, что юниты исключаются, если их родитель содержит запрещённое значение (IsInverse = true).
+    /// Логика фильтрации связей эмулируется через мок RelationshipMatcher.
     /// </summary>
     [Fact]
     public async Task GetUnitsByJobFilterAsync_ParentWithForbiddenTag_UnitIsExcluded()
@@ -373,7 +345,6 @@ public class UnitFilterServiceTests
         var unitWithValidParent = Guid.NewGuid();
         var unitWithInvalidParent = Guid.NewGuid();
 
-        // Подготовка тестовых данных: юниты
         context.Units.AddRange(
             BuildTestUnit(validParentId, "Parent_Valid", tagFieldId, "ОТВ.ЭК"),
             BuildTestUnit(invalidParentId, "Parent_Invalid", tagFieldId, "ПАРР-РРПТК-ОТВ.ЭК"),
@@ -381,7 +352,6 @@ public class UnitFilterServiceTests
             BuildTestUnit(unitWithInvalidParent, "Unit_Invalid", Guid.NewGuid(), "Val")
         );
 
-        // Подготовка тестовых данных: связи между юнитами
         context.UnitInUnits.AddRange(
             new UnitInUnit { ParentUnitId = validParentId, ChildUnitId = unitWithValidParent, DateCreated = DateTimeOffset.UtcNow },
             new UnitInUnit { ParentUnitId = invalidParentId, ChildUnitId = unitWithInvalidParent, DateCreated = DateTimeOffset.UtcNow }
@@ -389,8 +359,6 @@ public class UnitFilterServiceTests
 
         await context.SaveChangesAsync();
 
-        // Формируем тестовый объект Job с настройкой IsInverse = true
-        // IsInverse = true означает: исключить родителей, которые СОВПАДАЮТ с маской
         var job = new Job
         {
             Id = jobId,
@@ -430,20 +398,21 @@ public class UnitFilterServiceTests
             }
         };
 
-        // Настройка моков репозиториев
         var mocks = ArrangeRepositoryMocks(context);
 
-        // Переопределяем мок: возвращаем только родителей с запрещённым тегом.
-        // В реальном коде используется EF.Functions.ILike, в тесте — .Contains() для простоты.
-        // IsInverse = true в сервисе инвертирует результат, поэтому эти родители будут исключены.
-        mocks.UnitInValue.Setup(r => r.GetMatchingTargetIds(tagFieldId, It.IsAny<string>()))
-                             .Returns((Guid fId, string mask) =>
-                                 context.UnitInValues
-                                 .AsNoTracking()
-                                 .Where(uv => uv.FieldId == fId && uv.Value != null && uv.Value.Value.Contains("ПАРР-РРПТК-ОТВ.ЭК", StringComparison.OrdinalIgnoreCase))
-                                 .Select(uv => uv.UnitId)
-                                 .Distinct()
-                                 .AsQueryable());
+        // Эмуляция RelationshipMatcher: исключает unitWithInvalidParent
+        mocks.RelationshipMatcher.Setup(r => r.MatchAsync(
+                                    It.IsAny<IReadOnlyList<Guid>>(),
+                                    It.IsAny<IEnumerable<JobRelationshipFilter>>(),
+                                    It.IsAny<CancellationToken>()))
+                               .ReturnsAsync((IReadOnlyList<Guid> ids, IEnumerable<JobRelationshipFilter> filters, CancellationToken ct) =>
+                                   ids.Where(id => id == unitWithValidParent)
+                                      .Select(id => new UnitFilterMatchResult
+                                      {
+                                          UnitId = id,
+                                          ValidParentIds = new HashSet<Guid> { validParentId },
+                                          ValidChildIds = new HashSet<Guid>()
+                                      }).ToList());
 
         var logger = NullLoggerFactory.Instance.CreateLogger<Core.Services.UnitFilterService.UnitFilterService>();
         var service = CreateSut(mocks, logger);
@@ -459,8 +428,8 @@ public class UnitFilterServiceTests
     }
 
     /// <summary>
-    /// Проверяет логику IsFullMatch = true: юнит исключается, 
-    /// если хотя бы один из его родительских юнитов не соответствует фильтру.
+    /// Проверяет логику IsFullMatch = true: юнит исключается,
+    /// если хотя бы один из его родителей не соответствует фильтру.
     /// </summary>
     [Fact]
     public async Task GetUnitsByJobFilterAsync_IsFullMatch_UnitWithAnyNonMatchingParent_IsExcluded()
@@ -478,7 +447,6 @@ public class UnitFilterServiceTests
         var unitMixedId = Guid.NewGuid();
         var unitCleanId = Guid.NewGuid();
 
-        // Подготовка тестовых данных: юниты
         context.Units.AddRange(
             BuildTestUnit(parentGoodId, "Parent_Good", checkFieldId, "Good Parent"),
             BuildTestUnit(parentBadId, "Parent_Bad", checkFieldId, "Bad Parent"),
@@ -486,7 +454,6 @@ public class UnitFilterServiceTests
             BuildTestUnit(unitCleanId, "Unit_Clean", Guid.NewGuid(), "Clean")
         );
 
-        // Подготовка тестовых данных: связи между юнитами
         context.UnitInUnits.AddRange(
             new UnitInUnit { ParentUnitId = parentGoodId, ChildUnitId = unitMixedId, DateCreated = DateTimeOffset.UtcNow },
             new UnitInUnit { ParentUnitId = parentBadId, ChildUnitId = unitMixedId, DateCreated = DateTimeOffset.UtcNow },
@@ -495,8 +462,6 @@ public class UnitFilterServiceTests
 
         await context.SaveChangesAsync();
 
-        // Формируем тестовый объект Job с настройкой IsFullMatch = true
-        // IsFullMatch = true означает: ВСЕ родители должны соответствовать фильтру
         var job = new Job
         {
             Id = jobId,
@@ -536,19 +501,21 @@ public class UnitFilterServiceTests
             }
         };
 
-        // Настройка моков репозиториев
         var mocks = ArrangeRepositoryMocks(context);
 
-        // Переопределяем мок: возвращаем только родителей, соответствующих маске "Good".
-        // В реальном коде используется EF.Functions.ILike, в тесте — .Contains() для простоты.
-        mocks.UnitInValue.Setup(r => r.GetMatchingTargetIds(checkFieldId, It.IsAny<string>()))
-                             .Returns((Guid fId, string mask) =>
-                                 context.UnitInValues
-                                 .AsNoTracking()
-                                 .Where(uv => uv.FieldId == fId && uv.Value != null && uv.Value.Value.Contains("Good", StringComparison.OrdinalIgnoreCase))
-                                 .Select(uv => uv.UnitId)
-                                 .Distinct()
-                                 .AsQueryable());
+        // Эмуляция RelationshipMatcher: исключает unitMixedId (один из родителей не проходит)
+        mocks.RelationshipMatcher.Setup(r => r.MatchAsync(
+                                    It.IsAny<IReadOnlyList<Guid>>(),
+                                    It.IsAny<IEnumerable<JobRelationshipFilter>>(),
+                                    It.IsAny<CancellationToken>()))
+                               .ReturnsAsync((IReadOnlyList<Guid> ids, IEnumerable<JobRelationshipFilter> filters, CancellationToken ct) =>
+                                   ids.Where(id => id == unitCleanId)
+                                      .Select(id => new UnitFilterMatchResult
+                                      {
+                                          UnitId = id,
+                                          ValidParentIds = new HashSet<Guid> { parentGoodId },
+                                          ValidChildIds = new HashSet<Guid>()
+                                      }).ToList());
 
         var logger = NullLoggerFactory.Instance.CreateLogger<Core.Services.UnitFilterService.UnitFilterService>();
         var service = CreateSut(mocks, logger);
@@ -563,10 +530,9 @@ public class UnitFilterServiceTests
         Assert.DoesNotContain(unitMixedId, resultIds);
     }
 
-
     /// <summary>
     /// Проверяет комбинацию флагов: IsParent=true, IsInverse=true, IsFullMatch=true.
-    /// Логика: юнит проходит, только если НИ ОДИН из его родителей не содержит запрещённое значение.
+    /// Юнит проходит, только если ни один из его родителей не содержит запрещённое значение.
     /// </summary>
     [Fact]
     public async Task GetUnitsByJobFilterAsync_IsParentAndInverseAndFullMatch_UnitWithAnyForbiddenParent_IsExcluded()
@@ -579,12 +545,11 @@ public class UnitFilterServiceTests
 
         var jobId = Guid.NewGuid();
         var tagFieldId = Guid.NewGuid();
-        var parentForbiddenId = Guid.NewGuid(); // Родитель с запрещённым тегом
-        var parentCleanId = Guid.NewGuid();     // Родитель без запрещённого тега
-        var unitMixedId = Guid.NewGuid();       // Юнит с одним "плохим" и одним "хорошим" родителем
-        var unitAllCleanId = Guid.NewGuid();    // Юнит только с "хорошими" родителями
+        var parentForbiddenId = Guid.NewGuid();
+        var parentCleanId = Guid.NewGuid();
+        var unitMixedId = Guid.NewGuid();
+        var unitAllCleanId = Guid.NewGuid();
 
-        // Подготовка тестовых данных: юниты
         context.Units.AddRange(
             BuildTestUnit(parentForbiddenId, "Parent_Forbidden", tagFieldId, "FORBIDDEN-TAG"),
             BuildTestUnit(parentCleanId, "Parent_Clean", tagFieldId, "CLEAN-TAG"),
@@ -592,9 +557,6 @@ public class UnitFilterServiceTests
             BuildTestUnit(unitAllCleanId, "Unit_AllClean", Guid.NewGuid(), "AllClean")
         );
 
-        // Подготовка тестовых данных: связи
-        // unitMixed имеет обоих родителей — один с запрещённым тегом, один без
-        // unitAllClean имеет только "чистого" родителя
         context.UnitInUnits.AddRange(
             new UnitInUnit { ParentUnitId = parentForbiddenId, ChildUnitId = unitMixedId, DateCreated = DateTimeOffset.UtcNow },
             new UnitInUnit { ParentUnitId = parentCleanId, ChildUnitId = unitMixedId, DateCreated = DateTimeOffset.UtcNow },
@@ -603,10 +565,6 @@ public class UnitFilterServiceTests
 
         await context.SaveChangesAsync();
 
-        // Формируем тестовый объект Job с комбинацией флагов:
-        // IsParent = true: проверяем родительские связи
-        // IsInverse = true: исключаем родителей, которые СОВПАДАЮТ с маской
-        // IsFullMatch = true: ВСЕ родители должны пройти фильтр (ни один не должен совпасть с маской)
         var job = new Job
         {
             Id = jobId,
@@ -646,21 +604,21 @@ public class UnitFilterServiceTests
             }
         };
 
-        // Настройка моков репозиториев
         var mocks = ArrangeRepositoryMocks(context);
 
-        // Переопределяем мок: возвращаем только родителей, содержащих "FORBIDDEN".
-        // В реальном коде используется EF.Functions.ILike, в тесте — .Contains() для простоты.
-        // Из-за IsInverse=true эти родители будут исключены из "валидных".
-        // Из-за IsFullMatch=true юнит пройдёт, только если ВСЕ его родители валидны.
-        mocks.UnitInValue.Setup(r => r.GetMatchingTargetIds(tagFieldId, It.IsAny<string>()))
-                             .Returns((Guid fId, string mask) =>
-                                 context.UnitInValues
-                                 .AsNoTracking()
-                                 .Where(uv => uv.FieldId == fId && uv.Value != null && uv.Value.Value.Contains("FORBIDDEN", StringComparison.OrdinalIgnoreCase))
-                                 .Select(uv => uv.UnitId)
-                                 .Distinct()
-                                 .AsQueryable());
+        // Эмуляция RelationshipMatcher: исключает unitMixedId (есть родитель с запрещённым тегом)
+        mocks.RelationshipMatcher.Setup(r => r.MatchAsync(
+                                    It.IsAny<IReadOnlyList<Guid>>(),
+                                    It.IsAny<IEnumerable<JobRelationshipFilter>>(),
+                                    It.IsAny<CancellationToken>()))
+                               .ReturnsAsync((IReadOnlyList<Guid> ids, IEnumerable<JobRelationshipFilter> filters, CancellationToken ct) =>
+                                   ids.Where(id => id == unitAllCleanId)
+                                      .Select(id => new UnitFilterMatchResult
+                                      {
+                                          UnitId = id,
+                                          ValidParentIds = new HashSet<Guid> { parentCleanId },
+                                          ValidChildIds = new HashSet<Guid>()
+                                      }).ToList());
 
         var logger = NullLoggerFactory.Instance.CreateLogger<Core.Services.UnitFilterService.UnitFilterService>();
         var service = CreateSut(mocks, logger);
@@ -671,15 +629,7 @@ public class UnitFilterServiceTests
         // === Assert ===
         var resultIds = result.Select(u => u.Id).ToList();
 
-        // unitAllCleanId должен остаться: у него один родитель, и он не содержит запрещённый тег
         Assert.Contains(unitAllCleanId, resultIds);
-
-        // unitMixedId должен быть исключён: у него есть родитель с запрещённым тегом.
-        // Логика: 
-        // 1. GetMatchingTargetIds возвращает {parentForbiddenId}
-        // 2. IsInverse=true → валидные родители = все.Кроме({parentForbiddenId}) = {parentCleanId}
-        // 3. IsFullMatch=true → проверяем: все родители {parentForbiddenId, parentCleanId} входят в {parentCleanId}? Нет.
-        // 4. Юнит исключается.
         Assert.DoesNotContain(unitMixedId, resultIds);
     }
 }