1230 lines
44 KiB
C#
1230 lines
44 KiB
C#
using FluentAssertions;
|
|
using LCU.API.Internal.DocumentLib.Containers;
|
|
using LCU.API.Internal.DocumentLib.Repositories;
|
|
using LCU.API.Internal.DocumentLibTest.TestDataFactories;
|
|
using LCU.API.Internal.DocumentLibTest.TestDoubles;
|
|
using LCU.Library.DocumentType.Models.Responses;
|
|
using LCU.Library.Internal.DocumentIngestorModels.Models.Pagination;
|
|
using LCU.Library.Internal.DocumentModels.Requests.Search;
|
|
using MongoDB.Driver;
|
|
|
|
namespace LCU.API.Internal.DocumentLibTest.Repositories;
|
|
|
|
public class DocumentInformationRepositoryTest : IDisposable
|
|
{
|
|
private readonly IDocumentInformationRepository _repository;
|
|
|
|
private readonly FakeMongoCollectionFactory _collectionFactory = new();
|
|
|
|
public DocumentInformationRepositoryTest()
|
|
{
|
|
_repository = new DocumentInformationRepository(_collectionFactory);
|
|
}
|
|
|
|
[SetUp]
|
|
public async Task SetUp()
|
|
{
|
|
var collection = _collectionFactory.GetCollection<DocumentInformation>();
|
|
await collection.DeleteManyAsync(Builders<DocumentInformation>.Filter.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentInformation_NoMatchingId_ReturnsNull()
|
|
{
|
|
await SearchableDocumentFactory(d => d.CreatedDate = DateTime.Now.AddDays(1));
|
|
var actualDocument = await _repository.GetDocumentInformation(Guid.NewGuid());
|
|
|
|
Assert.Null(actualDocument);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_NameMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
Name = document.Name
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_NameNotMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
Name = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_TypeMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
Type = document.Type
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_TypeNotMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
Type = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_ScanStatusMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
ScanStatus = document.ScanStatus
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_ScanStatusNotMatched_DoesNotReturnDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
ScanStatus = !document.ScanStatus
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_SourceMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
Source = document.Source
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_SourceNotMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
Source = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_DataSourceMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
DataSource = document.DataSource
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_DataSourceNotMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
DataSource = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_TraceIdMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
TraceId = document.TraceId
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_TraceIdNotMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
TraceId = Guid.NewGuid()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_PersonNumbersEqualsMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
PersonNumbersEquals = document.PersonNumbers.FirstOrDefault()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_PersonNumbersEqualsNotMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
PersonNumbersEquals = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_PersonNumbersContainsMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
PersonNumbersContains = document.PersonNumbers
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_PersonNumbersContainsPartiallyMatched_DoesNotReturnDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
PersonNumbersContains = EnumerableDataSeriesFactory.CreateSeries(() => Guid.NewGuid().ToString(), 5).Concat(document.PersonNumbers).ToArray()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_PersonNumbersContainsNotMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
PersonNumbersContains = EnumerableDataSeriesFactory.CreateSeries(() => Guid.NewGuid().ToString(), 5).ToArray()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_PersonNumbersContainsAnyMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
PersonNumbersContainsAny = document.PersonNumbers
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_PersonNumbersContainsAnyPartiallyMatched_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
PersonNumbersContainsAny = EnumerableDataSeriesFactory.CreateSeries(() => Guid.NewGuid().ToString(), 5).Concat(document.PersonNumbers).ToArray()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_PersonNumbersContainsAnyNoneMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
PersonNumbersContainsAny = EnumerableDataSeriesFactory.CreateSeries(() => Guid.NewGuid().ToString(), 5).ToArray()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_OrganizationNumbersEqualsMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
OrganizationNumbersEquals = document.OrganizationNumbers.FirstOrDefault()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_OrganizationNumbersEqualsNotMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
OrganizationNumbersEquals = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_OrganizationNumbersContainsMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
OrganizationNumbersContains = new [] { document.OrganizationNumbers.First() }
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_OrganizationNumbersContainsPartiallyMatched_DoesNotReturnDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
OrganizationNumbersContains = EnumerableDataSeriesFactory.CreateSeries(() => Guid.NewGuid().ToString(), 5).Concat(document.OrganizationNumbers).ToArray()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_OrganizationNumbersContainsNotMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
OrganizationNumbersContains = EnumerableDataSeriesFactory.CreateSeries(() => Guid.NewGuid().ToString(), 5).ToArray()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_OrganizationNumbersContainsAnyMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
OrganizationNumbersContainsAny = document.OrganizationNumbers
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_OrganizationNumbersContainsAnyPartiallyMatched_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
OrganizationNumbersContainsAny = EnumerableDataSeriesFactory.CreateSeries(() => Guid.NewGuid().ToString(), 5).Concat(document.OrganizationNumbers).ToArray()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_OrganizationNumbersContainsAnyNoneMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
OrganizationNumbersContainsAny = EnumerableDataSeriesFactory.CreateSeries(() => Guid.NewGuid().ToString(), 5).ToArray()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AccountNumberEqualsMatchedExactly_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AccountNumberEquals = document.AccountNumber
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AccountNumberEqualsNotMatched_DoesNotReturnDocument()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AccountNumberEquals = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AccountNumberContainsAnyNumberInFilter_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AccountNumberContainsAny = EnumerableDataSeriesFactory.CreateSeries(() => Guid.NewGuid().ToString(), 5).Concat(new[]{ document.AccountNumber }).ToArray()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AccountNumberContainsAnyNumberNotInFilter_DoesNotReturnDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AccountNumberContainsAny = EnumerableDataSeriesFactory.CreateSeries(() => Guid.NewGuid().ToString(), 5).Concat(document.OrganizationNumbers).ToArray()
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributesEqualsMatchedExactly_ReturnsDocument()
|
|
{
|
|
var attribute = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
var document = await SearchableDocumentFactory(d => d.Attributes[attribute] = value);
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesEquals = new Dictionary<string, string>
|
|
{
|
|
[attribute] = value
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributesEqualsNotMatched_DoesNotReturnDocument()
|
|
{
|
|
var attribute = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
await SearchableDocumentFactory(d => d.Attributes[attribute] = value);
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesEquals = new Dictionary<string, string>
|
|
{
|
|
[attribute] = Guid.NewGuid().ToString()
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributesContainsAndAttributeMatchesExactly_ReturnsDocument()
|
|
{
|
|
var attribute = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
var document = await SearchableDocumentFactory(d => d.Attributes[attribute] = value);
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesContains = new Dictionary<string, string>
|
|
{
|
|
[attribute] = value
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributesContainsAndAttributeMatchesDifferentCase_ReturnsDocument()
|
|
{
|
|
var attribute = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
var document = await SearchableDocumentFactory(d => d.Attributes[attribute] = value);
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesContains = new Dictionary<string, string>
|
|
{
|
|
[attribute] = value.ToLower()
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributesContainsAndAttributeMatchesOnWordBoundary_ReturnsDocument()
|
|
{
|
|
var attribute = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
var document = await SearchableDocumentFactory(d => d.Attributes[attribute] = $"{Guid.NewGuid()} {value},{Guid.NewGuid()}");
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesContains = new Dictionary<string, string>
|
|
{
|
|
[attribute] = value
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributesContainsAndAttributeMatchesWithinAnotherWord_DoesNotReturnDocument()
|
|
{
|
|
var attribute = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
await SearchableDocumentFactory(d => d.Attributes[attribute] = $"{Guid.NewGuid()}{value}{Guid.NewGuid()}");
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesContains = new Dictionary<string, string>
|
|
{
|
|
[attribute] = value
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributeContainsAnyAttributeMatchesExactlyOne_ReturnsDocument()
|
|
{
|
|
var attribute = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
var document = await SearchableDocumentFactory(d => d.Attributes[attribute] = value);
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesContainsAny = new Dictionary<string, string>
|
|
{
|
|
[attribute] = $"{Guid.NewGuid()},{value},{Guid.NewGuid()}"
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributeContainsAnyAttributeMatchesOneDifferentCase_ReturnsDocument()
|
|
{
|
|
var attribute = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
var document = await SearchableDocumentFactory(d => d.Attributes[attribute] = value);
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesContainsAny = new Dictionary<string, string>
|
|
{
|
|
[attribute] = $"{Guid.NewGuid()},{value.ToLower()},{Guid.NewGuid()}"
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributeContainsAnyAttributeMatchesNone_DoesNotReturnDocument()
|
|
{
|
|
var attribute = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
await SearchableDocumentFactory(d => d.Attributes[attribute] = value);
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesContainsAny = new Dictionary<string, string>
|
|
{
|
|
[attribute] = $"{Guid.NewGuid()},{Guid.NewGuid()},{Guid.NewGuid()}"
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributesContainsMatchAndAttributeContainsAnyMatch_ReturnsDocument()
|
|
{
|
|
var attributeContains = Guid.NewGuid().ToString();
|
|
var attributeContainsAny = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
var document = await SearchableDocumentFactory(d =>
|
|
{
|
|
d.Attributes[attributeContains] = $"{Guid.NewGuid()},{value},{Guid.NewGuid()}";
|
|
d.Attributes[attributeContainsAny] = value;
|
|
});
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesContains = new Dictionary<string, string>
|
|
{
|
|
[attributeContains] = value
|
|
},
|
|
AttributesContainsAny = new Dictionary<string, string>
|
|
{
|
|
[attributeContainsAny] = $"{Guid.NewGuid()},{value},{Guid.NewGuid()}"
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributesContainsMatchAndAttributeContainsAnyNotMatched_DoesNotReturnDocument()
|
|
{
|
|
var attributeContains = Guid.NewGuid().ToString();
|
|
var attributeContainsAny = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
await SearchableDocumentFactory(d =>
|
|
{
|
|
d.Attributes[attributeContains] = $"{Guid.NewGuid()},{value},{Guid.NewGuid()}";
|
|
d.Attributes[attributeContainsAny] = value;
|
|
});
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesContains = new Dictionary<string, string>
|
|
{
|
|
[attributeContains] = value
|
|
},
|
|
AttributesContainsAny = new Dictionary<string, string>
|
|
{
|
|
[attributeContainsAny] = $"{Guid.NewGuid()},{Guid.NewGuid()},{Guid.NewGuid()}"
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_AttributesContainsNotMatchedAndAttributeContainsAnyMatch_DoesNotReturnDocument()
|
|
{
|
|
var attributeContains = Guid.NewGuid().ToString();
|
|
var attributeContainsAny = Guid.NewGuid().ToString();
|
|
var value = Guid.NewGuid().ToString();
|
|
await SearchableDocumentFactory(d =>
|
|
{
|
|
d.Attributes[attributeContains] = $"{Guid.NewGuid()},{value},{Guid.NewGuid()}";
|
|
d.Attributes[attributeContainsAny] = value;
|
|
});
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
AttributesContains = new Dictionary<string, string>
|
|
{
|
|
[attributeContains] = Guid.NewGuid().ToString()
|
|
},
|
|
AttributesContainsAny = new Dictionary<string, string>
|
|
{
|
|
[attributeContainsAny] = $"{Guid.NewGuid()},{value},{Guid.NewGuid()}"
|
|
}
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_CreatedDateMinimumLessThanCreatedDate_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
CreatedDateMinimum = document.CreatedDate.AddDays(-1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_CreatedDateMinimumGreaterThanCreatedDate_DoesNotReturnDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
CreatedDateMinimum = document.CreatedDate.AddDays(1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_CreatedDateMaximumGreaterThanCreatedDate_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
CreatedDateMaximum = document.CreatedDate.AddDays(1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_CreatedDateMaximumLessThanCreatedDate_DoesNotReturnDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
CreatedDateMaximum = document.CreatedDate.AddDays(-1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_UploadDateMinimumLessThanCreatedDate_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
UploadDateMinimum = document.CreatedDate.AddDays(-1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_UploadDateMinimumGreaterThanCreatedDate_DoesNotReturnDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
UploadDateMinimum = document.CreatedDate.AddDays(1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_UploadDateMaximumGreaterThanCreatedDate_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
UploadDateMaximum = document.CreatedDate.AddDays(1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_UploadDateMaximumLessThanCreatedDate_DoesNotReturnDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
UploadDateMaximum = document.CreatedDate.AddDays(-1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_LastModifiedMinimumLessThanCreatedDate_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
LastModifiedMinimum = document.CreatedDate.AddDays(-1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_LastModifiedMinimumGreaterThanCreatedDate_DoesNotReturnDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
LastModifiedMinimum = document.CreatedDate.AddDays(1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_LastModifiedDateMaximumGreaterThanCreatedDate_ReturnsDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
LastModifiedDateMaximum = document.CreatedDate.AddDays(1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(1, documents.Count);
|
|
documents.Single().Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_LastModifiedMaximumLessThanCreatedDate_DoesNotReturnDocument()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
var filter = new DocumentInformationFilter
|
|
{
|
|
LastModifiedDateMaximum = document.CreatedDate.AddDays(-1)
|
|
};
|
|
|
|
var documents = await _repository.SearchDocumentInformation(filter);
|
|
|
|
Assert.AreEqual(0, documents.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_Skip_BypassesTheSkippedDocuments()
|
|
{
|
|
const int skip = 5;
|
|
var documents = await Task.WhenAll(EnumerableDataSeriesFactory.CreateSeries(async () => await SearchableDocumentFactory(), skip * 2));
|
|
var filter = new DocumentInformationFilter { AccountNumberContainsAny = documents.Select(d => d.AccountNumber).ToArray() };
|
|
|
|
var searchResult = await _repository.SearchDocumentInformation(filter, skip);
|
|
|
|
searchResult.Should().HaveSameCount(documents[skip..]);
|
|
searchResult.Should().AllSatisfy(r => documents.Should().ContainEquivalentOf(r, d => d.Using(DateTimeComparison.Truncated)));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_Take_OnlyReturnsThatManyDocuments()
|
|
{
|
|
const int take = 5;
|
|
var documents = await Task.WhenAll(EnumerableDataSeriesFactory.CreateSeries(async () => await SearchableDocumentFactory(), take * 2));
|
|
var filter = new DocumentInformationFilter { AccountNumberContainsAny = documents.Select(d => d.AccountNumber).ToArray() };
|
|
|
|
var searchResult = await _repository.SearchDocumentInformation(filter, null, take);
|
|
|
|
searchResult.Should().HaveCount(take);
|
|
searchResult.Should().AllSatisfy(r => documents.Should().ContainEquivalentOf(r, d => d.Using(DateTimeComparison.Truncated)));
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentInformationByBlobId_NoMatchingId_ReturnsNull()
|
|
{
|
|
await SearchableDocumentFactory();
|
|
|
|
var actualDocument = await _repository.GetDocumentInformationByBlobId(Guid.NewGuid());
|
|
|
|
Assert.Null(actualDocument);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SaveDocumentInformation_AllCases_InsertsDocumentAndReturnsIt()
|
|
{
|
|
var document = DocumentInformationFactory.CreateDocumentInformation();
|
|
|
|
var inserted = await _repository.SaveDocumentInformation(document);
|
|
|
|
inserted.Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
var found = (await
|
|
(await _collectionFactory
|
|
.GetCollection<DocumentInformation>()
|
|
.FindAsync(d => d.DocumentId == document.DocumentId))
|
|
.ToListAsync()
|
|
).SingleOrDefault();
|
|
inserted.Should().BeEquivalentTo(found, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdateDocumentInformation_DocumentDoesNotExist_ThrowsException()
|
|
{
|
|
var id = Guid.NewGuid();
|
|
var document = DocumentInformationFactory.CreateDocumentInformation();
|
|
|
|
await _repository.UpdateDocumentInformation(id, document);
|
|
|
|
var found = await _collectionFactory
|
|
.GetCollection<DocumentInformation>()
|
|
.CountDocumentsAsync(d => d.DocumentId == id);
|
|
Assert.AreEqual(0, found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdateDocumentInformation_DocumentExists_FullyReplacesWithNewAndReturnsNew()
|
|
{
|
|
var existingDocument = await SearchableDocumentFactory();
|
|
var updatedDocument = DocumentInformationFactory.CreateDocumentInformation();
|
|
updatedDocument.DocumentId = existingDocument.DocumentId;
|
|
|
|
var updated = await _repository.UpdateDocumentInformation(existingDocument.DocumentId, updatedDocument);
|
|
|
|
updated.Should().BeEquivalentTo(updatedDocument, d => d.Using(DateTimeComparison.Truncated));
|
|
var found = (await
|
|
(await _collectionFactory
|
|
.GetCollection<DocumentInformation>()
|
|
.FindAsync(d => d.DocumentId == existingDocument.DocumentId))
|
|
.ToListAsync()
|
|
).SingleOrDefault();
|
|
updated.Should().BeEquivalentTo(found, d => d.Using(DateTimeComparison.Truncated));
|
|
}
|
|
|
|
[Test]
|
|
public async Task RemoveDocumentInformation_DocumentDoesNotExist_ReturnsNull()
|
|
{
|
|
var removed = await _repository.RemoveDocumentInformation(Guid.NewGuid());
|
|
|
|
Assert.IsNull(removed);
|
|
}
|
|
|
|
[Test]
|
|
public async Task RemoveDocumentInformation_DocumentExists_DeletesAndReturnsDeleted()
|
|
{
|
|
var document = await SearchableDocumentFactory();
|
|
|
|
var removed = await _repository.RemoveDocumentInformation(document.DocumentId);
|
|
|
|
removed.Should().BeEquivalentTo(document, d => d.Using(DateTimeComparison.Truncated));
|
|
var found = await _collectionFactory
|
|
.GetCollection<DocumentInformation>()
|
|
.CountDocumentsAsync(d => d.DocumentId == document.DocumentId);
|
|
Assert.AreEqual(0, found);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_SortsDocumentsWithOneSort()
|
|
{
|
|
var numberOfDocuments = 25;
|
|
var documents = await SearchableMultiDocumentFactory(numberOfDocuments);
|
|
|
|
// Using UploadDate as CreatedDate has AddDays(i % 3) to create duplicates.
|
|
// If sorted by just CreatedDate, the order may be different when it is pulled from the collection causing the test to fail
|
|
var sort = new List<SortableField>
|
|
{
|
|
new()
|
|
{
|
|
Field = "UploadDate",
|
|
Position = 0,
|
|
IsDescending = true
|
|
}
|
|
};
|
|
|
|
// Sort descending on upload date
|
|
documents.Sort((a, b) => b.UploadDate.CompareTo(a.UploadDate));
|
|
|
|
var searchResult = await _repository.SearchDocumentInformation(new DocumentInformationFilter(), null, numberOfDocuments, sort);
|
|
|
|
documents.Should().BeInDescendingOrder(a => a.UploadDate);
|
|
searchResult.Should().BeInDescendingOrder(a => a.UploadDate);
|
|
searchResult.Should().BeEquivalentTo(documents, d => d.Using(DateTimeComparison.Truncated).WithStrictOrdering());
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_SortsDocumentsWithMultipleSortsAndMaintainsPositionOrder()
|
|
{
|
|
var numberOfDocuments = 25;
|
|
var documents = await SearchableMultiDocumentFactory(numberOfDocuments);
|
|
|
|
var sort = new List<SortableField>
|
|
{
|
|
new()
|
|
{
|
|
Field = "Name",
|
|
Position = 2,
|
|
IsDescending = false
|
|
},
|
|
new()
|
|
{
|
|
Field = "CreatedDate",
|
|
Position = 0,
|
|
IsDescending = false
|
|
},
|
|
new()
|
|
{
|
|
Field = "UploadDate",
|
|
Position = 1,
|
|
IsDescending = false
|
|
}
|
|
};
|
|
|
|
// Sort ascending on created date, then ascending on upload date, then ascending on name
|
|
documents = documents.OrderBy(x => x.CreatedDate).ThenBy(x => x.UploadDate).ThenBy(x => x.Name).ToList();
|
|
|
|
var searchResult = await _repository.SearchDocumentInformation(new DocumentInformationFilter(), null, numberOfDocuments, sort);
|
|
|
|
searchResult.Should().BeEquivalentTo(documents, d => d.Using(DateTimeComparison.Truncated).WithStrictOrdering());
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentsForCleanup_Success()
|
|
{
|
|
var documents = new List<DocumentInformation>();
|
|
|
|
for (var i=0; i < 3; i++)
|
|
{
|
|
var document = DocumentInformationFactory.CreateDocumentInformation();
|
|
document.CreatedDate = document.CreatedDate.AddMonths(i % 3 * -1);
|
|
document.UploadDate = document.UploadDate.AddDays(i);
|
|
|
|
documents.Add(document);
|
|
}
|
|
|
|
documents[1].DocumentBlobId = null;
|
|
documents = await SearchableMultiDocumentFactory(documents);
|
|
|
|
var request = new GetDocumentCleanupRequest
|
|
{
|
|
DocumentCodeDetailInfos = new List<DocumentCodeDetailsResponse>
|
|
{
|
|
new()
|
|
{
|
|
DocumentCode = documents[0].Type,
|
|
InternalRetentionMonths = 3
|
|
},
|
|
new()
|
|
{
|
|
DocumentCode = documents[1].Type,
|
|
InternalRetentionMonths = 1
|
|
},
|
|
new()
|
|
{
|
|
DocumentCode = documents[2].Type,
|
|
InternalRetentionMonths = 1
|
|
}
|
|
},
|
|
Limit = 10
|
|
};
|
|
var expectedResults = documents.Where(document =>
|
|
{
|
|
var docCodeDetail = request.DocumentCodeDetailInfos
|
|
.FirstOrDefault(docCodeDetail => document.Type == docCodeDetail.DocumentCode);
|
|
|
|
return DateTime.Now >= document.CreatedDate.AddMonths(docCodeDetail!.InternalRetentionMonths)
|
|
&& document.DocumentBlobId is not null;
|
|
}).Select(document => document.DocumentId).ToList();
|
|
|
|
var result = await _repository.GetDocumentsForCleanup(request);
|
|
|
|
result.Should().BeEquivalentTo(expectedResults);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentsForCleanup_Success_NoDocumentsFound()
|
|
{
|
|
var request = new GetDocumentCleanupRequest
|
|
{
|
|
DocumentCodeDetailInfos = new List<DocumentCodeDetailsResponse>
|
|
{
|
|
new()
|
|
{
|
|
DocumentCode = Guid.NewGuid().ToString(),
|
|
InternalRetentionMonths = 3
|
|
}
|
|
},
|
|
Limit = 10
|
|
};
|
|
|
|
var result = await _repository.GetDocumentsForCleanup(request);
|
|
|
|
Assert.IsEmpty(result);
|
|
}
|
|
|
|
private async Task<DocumentInformation> SearchableDocumentFactory(Action<DocumentInformation>? documentSetup = null)
|
|
{
|
|
var document = DocumentInformationFactory.CreateDocumentInformation();
|
|
documentSetup?.Invoke(document);
|
|
|
|
var collection = _collectionFactory.GetCollection<DocumentInformation>();
|
|
await collection.InsertOneAsync(document);
|
|
|
|
return document;
|
|
}
|
|
|
|
private async Task<List<DocumentInformation>> SearchableMultiDocumentFactory(int numberOfDocuments = 10, Action<DocumentInformation>? documentSetup = null)
|
|
{
|
|
var documents = new List<DocumentInformation>();
|
|
|
|
for(var i = 0; i < numberOfDocuments; i++)
|
|
{
|
|
var document = DocumentInformationFactory.CreateDocumentInformation();
|
|
|
|
document.CreatedDate = document.CreatedDate.AddMonths(i % 3 * -1);
|
|
document.UploadDate = document.UploadDate.AddDays(i);
|
|
documentSetup?.Invoke(document);
|
|
|
|
documents.Add(document);
|
|
}
|
|
|
|
var collection = _collectionFactory.GetCollection<DocumentInformation>();
|
|
await collection.InsertManyAsync(documents);
|
|
|
|
return documents;
|
|
}
|
|
|
|
private async Task<List<DocumentInformation>> SearchableMultiDocumentFactory(List<DocumentInformation> documents)
|
|
{
|
|
var collection = _collectionFactory.GetCollection<DocumentInformation>();
|
|
await collection.InsertManyAsync(documents);
|
|
|
|
return documents;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_collectionFactory.Dispose();
|
|
}
|
|
} |