private static TestMetadata GetIdentityMetadata(string identity)
{
return(new TestMetadata()
{
{ DocumentReferenceKeys.DocumentIdentity, DocumentIdentity.Parse(identity) }
});
}
public void Comparision_of_two_equal_instances_yield_expected_result(string name1, string version1, string name2, string version2)
{
// ARRANGE
var identity1 = new DocumentIdentity(new DocumentName(name1), NuGetVersion.Parse(version1));
var identity2 = new DocumentIdentity(new DocumentName(name2), NuGetVersion.Parse(version2));
// ACT / ASSERT
Assert.AreEqual(identity1.GetHashCode(), identity2.GetHashCode());
Assert.AreEqual(identity1, identity2);
Assert.AreEqual(identity2, identity1);
Assert.AreEqual((object)identity1, (object)identity2);
Assert.AreEqual((object)identity2, (object)identity1);
#pragma warning disable CS1718 // Comparison made to same variable
Assert.True(identity1 == identity1);
Assert.True(identity2 == identity2);
Assert.False(identity1 != identity1);
Assert.False(identity2 != identity2);
#pragma warning restore CS1718 // Comparison made to same variable
Assert.True(identity1 == identity2);
Assert.True(identity2 == identity1);
Assert.False(identity1 != identity2);
Assert.False(identity2 != identity1);
}
public async Task <SearchResult> Search(SearchQuery searchQuery,
User user,
CancellationToken cancellationToken)
{
if (searchQuery == null)
{
throw new ArgumentNullException(nameof(searchQuery));
}
var response = await elasticClient.SearchAsync <DocumentInfoModel>(
sd => sd
.Index(options.IndexName)
.Query(qd => BuildSearchQuery(qd, searchQuery, user))
.Highlight(hs => hs
.Fields(hfd => hfd.Field("text"), hfd => hfd.Field("fileName")))
.Source(sfd => sfd.Includes(fd => fd.Field("fileName")))
.Skip(searchQuery.Skip)
.Take(searchQuery.Limit),
cancellationToken);
var foundDocuments = response.Hits.Select(hit => new FoundDocument
{
DocumentId = DocumentIdentity.FromString(hit.Id),
Matches = hit.Highlight
.ToDictionary(
x => x.Key,
x => (IReadOnlyCollection <IReadOnlyCollection <DocumentTextEntry> >)
x.Value.Select(y => textHighlighter.ParseHighlightedText(y)).ToArray()),
FileName = hit.Source.FileName
}).ToArray();
return(new SearchResult(foundDocuments, (int)response.HitsMetadata.Total.Value));
}
public static string GetClientId(this DocumentIdentity documentIdentity)
{
if (documentIdentity == null)
{
throw new ArgumentNullException(nameof(documentIdentity));
}
return(documentIdentity.Id);
}
private TestDocument[] GetInputsFromIdentities(params string[] identities)
{
return(identities.Select(identity =>
{
var input = new TestDocument();
input.TestMetadata[DocumentReferenceKeys.DocumentIdentity] = DocumentIdentity.Parse(identity);
return input;
})
.ToArray());
}
public void TryParse_returns_false_for_invalid_inputs(string value)
{
// ARRANGE
// ACT
var success = DocumentIdentity.TryParse(value, out var parsed);
// ASSERT
success.Should().BeFalse();
parsed.Should().BeNull();
}
public void DocumentIdentity_instances_can_be_compared_to_null()
{
Assert.False(DocumentIdentity.Parse("[email protected]") == null);
Assert.False(null == DocumentIdentity.Parse("[email protected]"));
Assert.True(DocumentIdentity.Parse("[email protected]") != null);
Assert.True(null != DocumentIdentity.Parse("[email protected]"));
Assert.True((DocumentIdentity?)null == (DocumentIdentity?)null);
Assert.False((DocumentIdentity?)null != (DocumentIdentity?)null);
}
public void Parse_returns_expected_identity_for_valid_inputs(string value, string name, string version)
{
// ARRANGE
var expected = new DocumentIdentity(new DocumentName(name), NuGetVersion.Parse(version));
// ACT
var actual = DocumentIdentity.Parse(value);
// ASSERT
actual.Should().Be(expected);
}
public void TestDocumentIdentity()
{
DocumentNumber docNum = new DocumentNumber(
TestUtilities.TEST_DOC_NUM.ToCharArray());
DocumentIdentity id = new DocumentIdentity(docNum, 2012, 07);
String idStr = id.ToString();
Assert.AreEqual(TestUtilities.TEST_DOC_ID, idStr);
DocumentIdentity newId = DocumentIdentity.Parse(idStr);
Assert.AreEqual(newId, id);
}
public void TryParse_returns_true_for_valid_inputs(string value, string name, string version)
{
// ARRANGE
var expected = new DocumentIdentity(new DocumentName(name), NuGetVersion.Parse(version));
// ACT
var success = DocumentIdentity.TryParse(value, out var parsed);
// ASSERT
success.Should().BeTrue();
parsed.Should().Be(expected);
}
public async Task <DocumentInfo> GetDocument(
DocumentIdentity id,
CancellationToken cancellationToken)
{
var response = await elasticClient.GetAsync <DocumentInfoModel>(
id.ToString(),
selector => selector
.Index(options.IndexName)
.SourceExcludes("text"),
cancellationToken);
return(ToDocumentInfo(response.Source, cancellationToken));
}
public void Parse_can_parse_fully_qualified_docs_references(string reference, string name, string version)
{
// ARRANGE
var expectedIdentity = new DocumentIdentity(new DocumentName(name), NuGetVersion.Parse(version));
// ACT
var parsed = DocumentReference.Parse(reference);
// ASSERT
parsed
.Should().NotBeNull()
.And.BeOfType <FullyQualifiedDocumentReference>()
.And.Match <FullyQualifiedDocumentReference>(fqr => fqr.Identity == expectedIdentity);
}
public void WithVersion_returns_a_new_instance_with_a_different_version()
{
// ARRANGE
var initialIdentity = new DocumentIdentity(new DocumentName("name1"), NuGetVersion.Parse("1.0"));
var expectedNewIdentity = new DocumentIdentity(new DocumentName("name1"), NuGetVersion.Parse("2.0"));
// ACT
var actualNewIdentity = initialIdentity.WithVersion(NuGetVersion.Parse("2.0"));
// ASSERT
actualNewIdentity
.Should().NotBeSameAs(initialIdentity)
.And.Be(expectedNewIdentity);
}
public async Task TestCreateTransWithTemplate()
{
Assert.IsTrue(_coreDriver.IsInitialize);
MasterDataCreater.CreateMasterData(_coreDriver);
await TemplateCreater.CreateTemplate(_coreDriver, _coreDriver.TmMgmt);
// create transaction data
DateTime date = DateTime.Parse("2012.07.02");
VendorEntry vendor = (VendorEntry)_coreDriver.TmMgmt.GetEntryTemplate(1)
.GenerateEntry();
vendor.SetValue(EntryTemplate.POSTING_DATE, date);
await vendor.SaveAsync(true);
CustomerEntry customer = (CustomerEntry)_coreDriver.TmMgmt.GetEntryTemplate(3)
.GenerateEntry();
customer.SetValue(EntryTemplate.POSTING_DATE, date);
customer.SetValue(EntryTemplate.AMOUNT, TestData.AMOUNT_CUSTOMER);
await customer.SaveAsync(true);
GLAccountEntry glEntry = (GLAccountEntry)_coreDriver.TmMgmt.GetEntryTemplate(2)
.GenerateEntry();
glEntry.SetValue(EntryTemplate.POSTING_DATE, date);
glEntry.SetValue(EntryTemplate.AMOUNT, TestData.AMOUNT_GL);
await glEntry.SaveAsync(true);
TransactionDataManagement transManagement = _coreDriver.TransMgmt;
// month 08
date = DateTime.Parse("2012.08.02");
HeadEntity headEntity = await DocumentCreater.CreateVendorDoc(_coreDriver,
date);
DocumentIdentity docId = headEntity.DocIdentity;
transManagement.ReverseDocument(docId);
// check
TransactionDataChecker.CheckTransactionData(_coreDriver);
// reload
await _coreDriver.RestartAsync();
TransactionDataChecker.CheckTransactionData(_coreDriver);
}
public void TryResolveDocument_returns_null_if_document_cannot_be_resolved(string reference)
{
// ARRANGE
var sut = new DocumentReferenceResolver <string>();
sut.Add(DocumentIdentity.Parse("[email protected]"), "document1");
sut.Add(DocumentIdentity.Parse("[email protected]"), "document2");
// ACT
var result = sut.TryResolveDocument(DocumentReference.Parse(reference), "document1");
// ASSERT
result.Should().BeNull();
}
public void TryResolveDocument_can_resolved_fully_qualified_references_in_documents_without_identity(string reference)
{
// ARRANGE
var sut = new DocumentReferenceResolver <string>();
sut.Add(DocumentIdentity.Parse("[email protected]"), "document");
// ACT
var result = sut.TryResolveDocument(DocumentReference.Parse(reference), "some-other-document");
// ASSERT
result
.Should().NotBeNull()
.And.Be("document");
}
public void TryResolveDocument_returns_expected_document(string id1, string id2, string reference, string expectedResult)
{
// ARRANGE
var sut = new DocumentReferenceResolver <string>();
sut.Add(DocumentIdentity.Parse(id1), "document1");
sut.Add(DocumentIdentity.Parse(id2), "document2");
// ACT
var actualResult = sut.TryResolveDocument(DocumentReference.Parse(reference), "document1");
// ASSERT
actualResult
.Should().NotBeNull()
.And.Be(expectedResult);
}
public void Parse_returns_true_for_fully_qualified_docs_references(string reference, string name, string version)
{
// ARRANGE
var expectedIdentity = new DocumentIdentity(new DocumentName(name), NuGetVersion.Parse(version));
// ACT
var success = DocumentReference.TryParse(reference, out var parsed);
// ASSERT
success
.Should().BeTrue();
parsed
.Should().NotBeNull()
.And.BeOfType <FullyQualifiedDocumentReference>()
.And.Match <FullyQualifiedDocumentReference>(fqr => fqr.Identity == expectedIdentity);
}
public async Task Execute_adds_expected_metadata_from_string_config()
{
// ARRANGE
var input = new TestDocument();
var sut = new SetDocumentReferenceMetadata("name", "1.0");
// ACT
var output = await ExecuteAsync(input, sut).SingleAsync();
// ASSERT
output.Should().NotBeNull();
output.GetDocumentName().Should().NotBeNull().And.Be(new DocumentName("name"));
output.GetDocumentVersion().Should().NotBeNull().And.Be(NuGetVersion.Parse("1.0"));
output.GetDocumentIdentity().Should().NotBeNull().And.Be(DocumentIdentity.Parse("[email protected]"));
output.GetDocumentReference().Should().NotBeNull().And.Be(DocumentReference.Parse("ref:[email protected]"));
}
public async Task Execute_uses_Config_to_retrieve_document_identity()
{
// ARRANGE
var input = GetInputsFromIdentities("[email protected]");
var sut = new GatherVersions()
.WithDocumentIdentity(Config.FromValue(DocumentIdentity.Parse("[email protected]")));
// ACT
var output = await ExecuteAsync(input, sut).SingleAsync();
// ASSERT
output
.Should().ContainSingle(x => x.Key == DocumentReferenceKeys.LatestDocumentVersion)
.Which.Value
.Should().BeAssignableTo <NuGetVersion>()
.Which
.Should().Be(NuGetVersion.Parse("2.0"));
}
public async Task Execute_adds_AllDocumentVersions_metadata()
{
// ARRANGE
var inputs = GetInputsFromIdentities("[email protected]", "[email protected]", "[email protected]", "[email protected]");
// ACT
var output = (await ExecuteAsync(inputs)).First();
// ASSERT
output
.Should().ContainSingle(x => x.Key == DocumentReferenceKeys.AllDocumentVersions)
.Which.Value
.Should().BeAssignableTo <IReadOnlyList <IMetadata> >()
.Which
.Should().HaveCount(3);
var otherVersions = output.GetChildren(DocumentReferenceKeys.AllDocumentVersions);
foreach (var item in otherVersions)
{
item
.Should().Contain(x => x.Key == DocumentReferenceKeys.DocumentName)
.And.Contain(x => x.Key == DocumentReferenceKeys.DocumentVersion)
.And.Contain(x => x.Key == DocumentReferenceKeys.DocumentIdentity);
item.GetDocumentName()
.Should().NotBeNull()
.And.Be(new DocumentName("name1"));
}
otherVersions[0].GetDocumentVersion().Should().Be(NuGetVersion.Parse("1.0"));
otherVersions[0].GetDocumentIdentity().Should().Be(DocumentIdentity.Parse("[email protected]"));
otherVersions[0].GetDocumentReference().Should().Be(DocumentReference.Parse("ref:[email protected]"));
otherVersions[1].GetDocumentVersion().Should().Be(NuGetVersion.Parse("2.0"));
otherVersions[1].GetDocumentIdentity().Should().Be(DocumentIdentity.Parse("[email protected]"));
otherVersions[1].GetDocumentReference().Should().Be(DocumentReference.Parse("ref:[email protected]"));
otherVersions[2].GetDocumentVersion().Should().Be(NuGetVersion.Parse("3.0"));
otherVersions[2].GetDocumentIdentity().Should().Be(DocumentIdentity.Parse("[email protected]"));
otherVersions[2].GetDocumentReference().Should().Be(DocumentReference.Parse("ref:[email protected]"));
}
public async Task Execute_uses_the_configured_config_to_retrieve_a_documents_identity()
{
// ARRANGE
var input1 = new TestDocument(
"C:/source1.html",
"./destination1.html",
new TestMetadata(),
GetHtml(@"<a href=""ref:[email protected]"">Link</a>"));
var input2 = new TestDocument(
"C:/source2.html",
"./destination2.html",
new TestMetadata(),
GetHtml());
var input = new[] { input1, input2 };
var sut = new ResolveDocumentReferences()
.WithDocumentIdentity(Config.FromDocument(
d => d.Source == "C:/source1.html"
? DocumentIdentity.Parse("[email protected]")
: DocumentIdentity.Parse("[email protected]")
));
// ACT
var output = await ExecuteAsync(input, sut);
// ASSERT
output.Should().HaveCount(2);
var output1 = output.First();
var html = await output1.ParseAsHtmlAsync();
html.QuerySelectorAll("a")
.Should().ContainSingle("there should be a single <a/> element")
.Which.Should().BeAssignableTo <IHtmlAnchorElement>()
.Which.GetAttribute("href")
.Should().Be("destination2.html");
}
//TODO: current item should be active => handled by MarkNavbarItemsAsActive?
private TestMetadata GetDocumentReferenceMetadata(
string name = "name", string version = "1.0",
string latestVersion = "1.0", string latestDocumentVersion = "1.0",
IEnumerable <string>?allVersions = null)
{
allVersions ??= new[] { version, latestDocumentVersion, latestVersion }.Distinct().ToArray();
var documentName = new DocumentName(name);
var documentVersion = NuGetVersion.Parse(version);
var documentIdentity = new DocumentIdentity(documentName, documentVersion);
return(new TestMetadata()
{
{ DocumentReferenceKeys.DocumentName, documentName },
{ DocumentReferenceKeys.DocumentVersion, documentVersion },
{ DocumentReferenceKeys.DocumentIdentity, documentIdentity },
{ DocumentReferenceKeys.DocumentReference, new FullyQualifiedDocumentReference(documentIdentity) },
{ DocumentReferenceKeys.LatestDocumentVersion, NuGetVersion.Parse(latestDocumentVersion) },
{ DocumentReferenceKeys.LatestVersion, NuGetVersion.Parse(latestVersion) },
{
DocumentReferenceKeys.AllDocumentVersions,
allVersions
.Select(v =>
{
var version = NuGetVersion.Parse(v);
var identity = new DocumentIdentity(documentName, version);
return new TestDocument(new TestMetadata()
{
{ DocumentReferenceKeys.DocumentName, documentName },
{ DocumentReferenceKeys.DocumentVersion, version },
{ DocumentReferenceKeys.DocumentIdentity, identity },
{ DocumentReferenceKeys.DocumentReference, new FullyQualifiedDocumentReference(identity) }
});
})
.Cast <IDocument>()
.ToArray()
}
});
}
/// <inheritdoc />
protected override async Task <IEnumerable <IDocument> > ExecuteContextAsync(IExecutionContext context)
{
var outputs = new List <IDocument>();
var identities = new HashSet <DocumentIdentity>();
foreach (var input in context.Inputs)
{
var name = await m_DocumentName.GetValueAsync(input, context);
var version = await m_DocumentVersion.GetValueAsync(input, context);
var identity = new DocumentIdentity(name, version);
if (identities.Contains(identity))
{
throw new DuplicateDocumentIdentityException($"Multiple documents have the same identity '{identity}'");
}
else
{
identities.Add(identity);
}
var metadata = new Dictionary <string, object>()
{
{ DocumentReferenceKeys.DocumentName, name },
{ DocumentReferenceKeys.DocumentVersion, version },
{ DocumentReferenceKeys.DocumentIdentity, identity },
{ DocumentReferenceKeys.DocumentReference, new FullyQualifiedDocumentReference(identity) }
};
var output = input.Clone(metadata);
outputs.Add(output);
}
return(outputs);
}
public Task <Document> GetDocumentAsync(DocumentIdentity id)
{
throw new NotImplementedException();
}
public void Parse_throws_ArgumentException_for_invalid_inputs(string value)
{
Action act = () => DocumentIdentity.Parse(value);
act.Should().ThrowExactly <ArgumentException>();
}
public void ToString_returns_expected_value(string name, string version, string expectedValue)
{
var identity = new DocumentIdentity(new DocumentName(name), NuGetVersion.Parse(version));
identity.ToString().Should().Be(expectedValue);
}
public async Task TestCreateTransDataWithEntry()
{
Assert.IsTrue(_coreDriver.IsInitialize);
MasterDataCreater.CreateMasterData(_coreDriver);
// month 08, reverse document
DateTime date = DateTime.Parse("2012.07.02");
// ledger
VendorEntry vendorEntry = new VendorEntry(_coreDriver, _coreDriver.MdMgmt);
vendorEntry.SetValue(EntryTemplate.POSTING_DATE, date);
vendorEntry.SetValue(EntryTemplate.TEXT, TestData.TEXT_VENDOR_DOC);
vendorEntry.SetValue(VendorEntry.VENDOR, new MasterDataIdentity(
TestData.VENDOR_BUS));
vendorEntry.SetValue(VendorEntry.REC_ACC,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_CASH));
vendorEntry.SetValue(VendorEntry.GL_ACCOUNT,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_COST));
vendorEntry.SetValue(VendorEntry.BUSINESS_AREA, new MasterDataIdentity(
TestData.BUSINESS_AREA_WORK));
vendorEntry.SetValue(EntryTemplate.AMOUNT, TestData.AMOUNT_VENDOR);
await vendorEntry.SaveAsync(true);
// customer
CustomerEntry customerEntry = new CustomerEntry(_coreDriver, _coreDriver.MdMgmt);
customerEntry.SetValue(EntryTemplate.POSTING_DATE, date);
customerEntry.SetValue(EntryTemplate.TEXT, TestData.TEXT_CUSTOMER_DOC);
customerEntry.SetValue(CustomerEntry.CUSTOMER, new MasterDataIdentity(
TestData.CUSTOMER1));
customerEntry.SetValue(CustomerEntry.REC_ACC,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_BANK));
customerEntry.SetValue(CustomerEntry.GL_ACCOUNT,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_REV));
customerEntry.SetValue(EntryTemplate.AMOUNT, TestData.AMOUNT_CUSTOMER);
await customerEntry.SaveAsync(true);
// GL
GLAccountEntry glAccEntry = new GLAccountEntry(_coreDriver, _coreDriver.MdMgmt);
glAccEntry.SetValue(EntryTemplate.POSTING_DATE, date);
glAccEntry.SetValue(EntryTemplate.TEXT, TestData.TEXT_GL_DOC);
glAccEntry.SetValue(GLAccountEntry.SRC_ACCOUNT,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_BANK));
glAccEntry.SetValue(GLAccountEntry.DST_ACCOUNT,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_CASH));
glAccEntry.SetValue(EntryTemplate.AMOUNT, TestData.AMOUNT_GL);
await glAccEntry.SaveAsync(true);
TransactionDataManagement transManagement = _coreDriver.TransMgmt;
date = DateTime.Parse("2012.08.02");
HeadEntity headEntity = await DocumentCreater.CreateVendorDoc(_coreDriver,
date);
DocumentIdentity docId = headEntity.DocIdentity;
transManagement.ReverseDocument(docId);
// check
TransactionDataChecker.CheckTransactionData(_coreDriver);
// reload
await _coreDriver.RestartAsync();
TransactionDataChecker.CheckTransactionData(_coreDriver);
}