public async Task When_the_second_of_three_input_work_files_does_not_exist()
{
var remoteWorkFile0 = new RemoteWorkFile(null, "ML3AbF-qzIH5K9mVVxTlBX", "FCnaLL517YPRAnrcX2wlnKURpNPsp2d2pMPkcvCcpdY=", "docx");
var remoteWorkFile1 = new RemoteWorkFile(null, "S5uCdv7vnkTRzKKlTvhtaw", "FCnaLL517YPRAnrcX2wlnKURpNPsp2d2pMPkcvCcpdY=", "docx");
var remoteWorkFile2 = new RemoteWorkFile(null, "5J15gtlduA_xORR8j7ejSg", "FCnaLL517YPRAnrcX2wlnKURpNPsp2d2pMPkcvCcpdY=", "docx");
var input0 = new ConversionSourceDocument(remoteWorkFile0);
var input1 = new ConversionSourceDocument(remoteWorkFile1, pages: "2-");
var input2 = new ConversionSourceDocument(remoteWorkFile2);
mockServer
.Given(Request.Create().WithPath("/v2/contentConverters").UsingPost())
.RespondWith(Response.Create()
.WithStatusCode(480)
.WithHeader("Content-Type", "application/json")
.WithBody("{\"input\":{\"dest\":{\"format\":\"pdf\",\"pdfOptions\":{\"forceOneFilePerPage\":false}},\"sources\":[{\"fileId\":\"LxuuLktmmMaicAs1wMvvsQ\",\"pages\":\"\"},{\"fileId\":\"S5uCdv7vnkTRzKKlTvhtaw\",\"pages\":\"2-\"},{\"fileId\":\"5J15gtlduA_xORR8j7ejSg\",\"pages\":\"\"}]},\"minSecondsAvailable\":18000,\"errorCode\":\"WorkFileDoesNotExist\",\"errorDetails\":{\"in\":\"body\",\"at\":\"input.sources[1].fileId\"}}"));
await UtilAssert.ThrowsExceptionWithMessageAsync <RestApiErrorException>(
async() =>
{
await prizmDocServer.ConvertAsync(
new List <ConversionSourceDocument>
{
input0, input1, input2,
},
new DestinationOptions(DestinationFileFormat.Pdf));
}, "ConversionSourceDocument at index 1 refers to a remote work file which does not exist. It may have expired.");
}
public async Task When_requesting_PDF_OCR_but_the_feature_is_not_licensed()
{
mockServer
.Given(Request.Create().WithPath("/v2/contentConverters").UsingPost())
.RespondWith(Response.Create()
.WithStatusCode(480)
.WithHeader("Content-Type", "application/json")
.WithBody("{\"errorCode\":\"FeatureNotLicensed\",\"errorDetails\":{\"in\":\"body\",\"at\":\"input.dest.pdfOptions.ocr\"}}"));
var dummyInput = new ConversionSourceDocument(new RemoteWorkFile(null, null, null, null));
await UtilAssert.ThrowsExceptionWithMessageAsync <RestApiErrorException>(
async() =>
{
await prizmDocServer.ConvertAsync(dummyInput, new DestinationOptions(DestinationFileFormat.Pdf)
{
PdfOptions = new PdfDestinationOptions
{
Ocr = new OcrOptions
{
Language = "english",
},
},
});
}, "Remote server is not licensed to perform OCR when producing PDF output.");
}
public async Task When_there_are_multiple_source_inputs()
{
PrizmDocServerClient prizmDocServer = Util.CreatePrizmDocServerClient();
var source1 = new ConversionSourceDocument("documents/example.pdf");
var source2 = new ConversionSourceDocument("documents/example.pdf", pages: "97-99");
var source3 = new ConversionSourceDocument("documents/example.pdf");
IEnumerable <ConversionResult> results = await prizmDocServer.ConvertAsync(
new List <ConversionSourceDocument>
{
source1,
source2,
source3,
},
new DestinationOptions(DestinationFileFormat.Pdf)
{
PdfOptions = new PdfDestinationOptions()
{
ForceOneFilePerPage = true,
},
});
Assert.AreEqual(7, results.Count());
AssertSuccessResult(results.ElementAt(0), "1", source1);
AssertSuccessResult(results.ElementAt(1), "2", source1);
AssertErrorResult(results.ElementAt(2), "NoSuchPage", "97", source2);
AssertErrorResult(results.ElementAt(3), "NoSuchPage", "98", source2);
AssertErrorResult(results.ElementAt(4), "NoSuchPage", "99", source2);
AssertSuccessResult(results.ElementAt(5), "1", source3);
AssertSuccessResult(results.ElementAt(6), "2", source3);
}
public async Task When_server_supports_three_OCR_languages()
{
mockServer
.Given(Request.Create().WithPath("/v2/contentConverters").UsingPost())
.RespondWith(Response.Create()
.WithStatusCode(480)
.WithHeader("Content-Type", "application/json")
.WithBody("{\"errorCode\":\"InvalidInput\",\"errorDetails\":{\"in\":\"body\",\"at\":\"input.dest.pdfOptions.ocr.language\",\"expected\":{\"enum\":[\"english\",\"greek\",\"hebrew\"]}}}"));
var dummyInput = new ConversionSourceDocument(new RemoteWorkFile(null, null, null, null));
await UtilAssert.ThrowsExceptionWithMessageAsync <RestApiErrorException>(
async() =>
{
await prizmDocServer.ConvertAsync(dummyInput, new DestinationOptions(DestinationFileFormat.Pdf)
{
PdfOptions = new PdfDestinationOptions
{
Ocr = new OcrOptions
{
Language = "hylian",
},
},
});
}, "Unsupported OCR language \"hylian\". The remote server only supports the following OCR languages: \"english\", \"greek\", \"hebrew\".");
}
public async Task Will_POST_work_file_when_given_a_local_file_path()
{
AffinitySession affinitySession = Util.RestClient.CreateAffinitySession();
var input = new ConversionSourceDocument("documents/example.docx");
Assert.IsNull(input.RemoteWorkFile);
await input.EnsureUsableRemoteWorkFileAsync(affinitySession);
Assert.IsNotNull(input.RemoteWorkFile);
}
public async Task Will_throw_an_exception_if_given_a_path_to_a_local_file_which_cannot_be_found()
{
AffinitySession affinitySession = Util.RestClient.CreateAffinitySession();
var input = new ConversionSourceDocument("documents/does not exist.pdf");
Assert.IsNull(input.RemoteWorkFile);
await UtilAssert.ThrowsExceptionWithMessageAsync <FileNotFoundException>(
async() => { await input.EnsureUsableRemoteWorkFileAsync(affinitySession); },
"File not found: \"documents/does not exist.pdf\"");
}
public async Task With_local_file_path()
{
PrizmDocServerClient prizmDocServer = Util.CreatePrizmDocServerClient();
ConversionResult result = (await prizmDocServer.ConvertAsync("documents/example.docx", DestinationFileFormat.Tiff)).Single();
Assert.IsTrue(result.IsSuccess);
Assert.AreEqual(2, result.PageCount);
ConversionSourceDocument resultSourceDocument = result.Sources.ToList()[0];
Assert.IsNotNull(resultSourceDocument.RemoteWorkFile);
Assert.IsNull(resultSourceDocument.Password);
Assert.AreEqual("1-2", resultSourceDocument.Pages);
await result.RemoteWorkFile.SaveAsync("output.tiff");
FileAssert.IsTiff("output.tiff");
}
public async Task Will_reupload_an_existing_RemoteWorkFile_when_the_affinity_is_wrong()
{
AffinitySession session1 = Util.RestClient.CreateAffinitySession();
AffinitySession session2 = Util.RestClient.CreateAffinitySession();
RemoteWorkFile file1;
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes("File 1")))
{
file1 = await session1.UploadAsync(stream);
}
RemoteWorkFile file2;
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes("File 2")))
{
file2 = await session2.UploadAsync(stream);
}
Assert.AreNotEqual(file1.AffinityToken, file2.AffinityToken);
var source2 = new ConversionSourceDocument(file2);
RemoteWorkFile originalRemoteWorkFile = source2.RemoteWorkFile;
Assert.AreEqual(file2, originalRemoteWorkFile);
// Ensure file2 is re-uploaded to the same machine as file1...
await source2.EnsureUsableRemoteWorkFileAsync(Util.RestClient.CreateAffinitySession(), affinityToken : file1.AffinityToken);
// Verify source RemoteWorkFile assignment was changed to something new
Assert.AreNotEqual(source2.RemoteWorkFile, originalRemoteWorkFile);
// Verify the affinity token of file1 and source2.RemoteWorkFile now match
Assert.AreEqual(file1.AffinityToken, source2.RemoteWorkFile.AffinityToken);
// Verify the contents of the file are still correct
using (var stream = new MemoryStream())
{
await source2.RemoteWorkFile.CopyToAsync(stream);
stream.Position = 0;
using (var reader = new StreamReader(stream, Encoding.UTF8))
{
string text = reader.ReadToEnd();
Assert.AreEqual("File 2", text);
}
}
}
public async Task Just_the_first_page()
{
PrizmDocServerClient prizmDocServer = Util.CreatePrizmDocServerClient();
ConversionSourceDocument sourceDocument = new ConversionSourceDocument("documents/example.docx", pages: "1");
ConversionResult result = (await prizmDocServer.ConvertAsync(sourceDocument, DestinationFileFormat.Tiff)).Single();
Assert.IsTrue(result.IsSuccess);
Assert.AreEqual(1, result.PageCount);
ConversionSourceDocument resultSourceDocument = result.Sources.ToList()[0];
Assert.AreEqual(sourceDocument.RemoteWorkFile, resultSourceDocument.RemoteWorkFile);
Assert.IsNull(resultSourceDocument.Password);
Assert.AreEqual("1", resultSourceDocument.Pages);
await result.RemoteWorkFile.SaveAsync("output.tiff");
FileAssert.IsTiff("output.tiff");
}
public async Task When_the_product_is_not_licensed()
{
mockServer
.Given(Request.Create().WithPath("/v2/contentConverters").UsingPost())
.RespondWith(Response.Create()
.WithStatusCode(480)
.WithHeader("Content-Type", "application/json")
.WithBody("{\"errorCode\":\"LicenseCouldNotBeVerified\"}"));
var dummyInput = new ConversionSourceDocument(new RemoteWorkFile(null, null, null, null));
await UtilAssert.ThrowsExceptionWithMessageAsync <RestApiErrorException>(
async() =>
{
await prizmDocServer.ConvertAsync(dummyInput, new DestinationOptions(DestinationFileFormat.Pdf));
}, "Remote server does not have a valid license.");
}
public async Task Single_input()
{
PrizmDocServerClient prizmDocServer = Util.CreatePrizmDocServerClient();
ConversionResult result = await prizmDocServer.OcrToPdfAsync("documents/ocr/chaucer-scan-3-pages.pdf");
Assert.IsTrue(result.IsSuccess);
Assert.AreEqual(3, result.PageCount);
ConversionSourceDocument resultSourceDocument = result.Sources.ToList()[0];
Assert.IsNotNull(resultSourceDocument.RemoteWorkFile);
Assert.IsNull(resultSourceDocument.Password);
Assert.AreEqual("1-3", resultSourceDocument.Pages);
await result.RemoteWorkFile.SaveAsync("output.pdf");
FileAssert.IsPdf("output.pdf");
}
public async Task When_single_input_work_file_does_not_exist()
{
mockServer
.Given(Request.Create().WithPath("/v2/contentConverters").UsingPost())
.RespondWith(Response.Create()
.WithStatusCode(480)
.WithHeader("Content-Type", "application/json")
.WithBody("{\"input\":{\"dest\":{\"format\":\"pdf\",\"pdfOptions\":{\"forceOneFilePerPage\":false}},\"sources\":[{\"fileId\":\"ML3AbF-qzIH5K9mVVxTlBX\",\"pages\":\"\"}]},\"minSecondsAvailable\":18000,\"errorCode\":\"WorkFileDoesNotExist\",\"errorDetails\":{\"in\":\"body\",\"at\":\"input.sources[0].fileId\"}}"));
var originalRemoteWorkFile = new RemoteWorkFile(null, "ML3AbF-qzIH5K9mVVxTlBX", "FCnaLL517YPRAnrcX2wlnKURpNPsp2d2pMPkcvCcpdY=", "docx");
var originalConversionInput = new ConversionSourceDocument(originalRemoteWorkFile);
await UtilAssert.ThrowsExceptionWithMessageAsync <RestApiErrorException>(
async() =>
{
await prizmDocServer.ConvertAsync(originalConversionInput, new DestinationOptions(DestinationFileFormat.Pdf));
}, "ConversionSourceDocument refers to a remote work file which does not exist. It may have expired.");
}
public async Task Will_use_existing_RemoteWorkFile()
{
AffinitySession affinitySession = Util.RestClient.CreateAffinitySession();
RemoteWorkFile remoteWorkFile;
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes("Hello world!")))
{
remoteWorkFile = await affinitySession.UploadAsync(stream);
}
var input = new ConversionSourceDocument(remoteWorkFile);
Assert.AreEqual(remoteWorkFile, input.RemoteWorkFile);
await input.EnsureUsableRemoteWorkFileAsync(affinitySession);
Assert.AreEqual(remoteWorkFile, input.RemoteWorkFile);
}
public async Task Just_the_first_page()
{
PrizmDocServerClient prizmDocServer = Util.CreatePrizmDocServerClient();
var sourceDocument = new ConversionSourceDocument("documents/ocr/chaucer-scan-3-pages.pdf", pages: "1");
ConversionResult result = await prizmDocServer.ConvertToPdfAsync(sourceDocument);
Assert.IsTrue(result.IsSuccess);
Assert.AreEqual(1, result.PageCount);
ConversionSourceDocument resultSourceDocument = result.Sources.ToList()[0];
Assert.AreEqual(sourceDocument.RemoteWorkFile, resultSourceDocument.RemoteWorkFile);
Assert.IsNull(resultSourceDocument.Password);
Assert.AreEqual("1", resultSourceDocument.Pages);
await result.RemoteWorkFile.SaveAsync("output.pdf");
FileAssert.IsPdf("output.pdf");
}
public async Task When_using_a_single_source_input()
{
PrizmDocServerClient prizmDocServer = Util.CreatePrizmDocServerClient();
var sourceDocument = new ConversionSourceDocument("documents/example.pdf", pages: "97-99");
IEnumerable <ConversionResult> results = await prizmDocServer.ConvertAsync(sourceDocument, new DestinationOptions(DestinationFileFormat.Pdf)
{
PdfOptions = new PdfDestinationOptions()
{
ForceOneFilePerPage = true,
},
});
Assert.AreEqual(3, results.Count());
AssertErrorResult(results.ElementAt(0), "NoSuchPage", "97", sourceDocument);
AssertErrorResult(results.ElementAt(1), "NoSuchPage", "98", sourceDocument);
AssertErrorResult(results.ElementAt(2), "NoSuchPage", "99", sourceDocument);
}
public async Task Unknown_error_on_POST()
{
mockServer
.Given(Request.Create().WithPath("/v2/contentConverters").UsingPost())
.RespondWith(Response.Create()
.WithStatusCode(418)
.WithHeader("Content-Type", "application/json")
.WithBody("{\"errorCode\":\"BoilingOver\",\"errorDetails\":{\"in\":\"body\",\"at\":\"input.admin.enableTurboMode\"}}"));
var dummyInput = new ConversionSourceDocument(new RemoteWorkFile(null, null, null, null));
string expectedMessage = @"Remote server returned an error: I'm a teapot BoilingOver {
""in"": ""body"",
""at"": ""input.admin.enableTurboMode""
}";
await UtilAssert.ThrowsExceptionWithMessageAsync <RestApiErrorException>(
async() => { await prizmDocServer.ConvertAsync(dummyInput, new DestinationOptions(DestinationFileFormat.Pdf)); },
expectedMessage,
ignoreCase : true);
}
private async Task AssertSinglePageTiffResultsAsync(IEnumerable <ConversionResult> results, Action <string> customAssertions = null)
{
for (int i = 0; i < results.Count(); i++)
{
ConversionResult result = results.ElementAt(i);
Assert.IsTrue(result.IsSuccess);
Assert.AreEqual(1, result.PageCount, "Wrong page count for result");
ConversionSourceDocument resultSourceDocument = result.Sources.ToList()[0];
Assert.IsNotNull(resultSourceDocument.RemoteWorkFile);
Assert.IsNull(resultSourceDocument.Password);
Assert.AreEqual((i + 1).ToString(), resultSourceDocument.Pages, "Wrong source page range for result");
string filename = $"page-{i}.tiff";
await result.RemoteWorkFile.SaveAsync(filename);
FileAssert.IsTiff(filename);
customAssertions?.Invoke(filename);
}
}
public async Task Multiple_inputs_one_with_password()
{
PrizmDocServerClient prizmDocServer = Util.CreatePrizmDocServerClient();
ConversionSourceDocument sourceDocument1 = new ConversionSourceDocument("documents/example.docx");
ConversionSourceDocument sourceDocument2 = new ConversionSourceDocument("documents/password.docx", password: "******");
ConversionResult result = (await prizmDocServer.ConvertAsync(new[] { sourceDocument1, sourceDocument2 }, DestinationFileFormat.Tiff)).Single();
Assert.IsTrue(result.IsSuccess);
Assert.AreEqual(3, result.PageCount);
List <ConversionSourceDocument> resultSourceDocuments = result.Sources.ToList();
Assert.AreEqual(sourceDocument1.RemoteWorkFile, resultSourceDocuments[0].RemoteWorkFile);
Assert.IsNull(resultSourceDocuments[0].Password);
Assert.AreEqual("1-2", resultSourceDocuments[0].Pages);
Assert.AreEqual(sourceDocument2.RemoteWorkFile, resultSourceDocuments[1].RemoteWorkFile);
Assert.IsNull(resultSourceDocuments[1].Password);
Assert.AreEqual("1", resultSourceDocuments[1].Pages);
await result.RemoteWorkFile.SaveAsync("output.tiff");
FileAssert.IsTiff("output.tiff");
}
public async Task Multiple_inputs()
{
PrizmDocServerClient prizmDocServer = Util.CreatePrizmDocServerClient();
var sourceDocument1 = new ConversionSourceDocument("documents/ocr/color.bmp");
var sourceDocument2 = new ConversionSourceDocument("documents/ocr/text.bmp");
ConversionResult result = await prizmDocServer.OcrToPdfAsync(new ConversionSourceDocument[] { sourceDocument1, sourceDocument2 });
Assert.IsTrue(result.IsSuccess);
Assert.AreEqual(2, result.PageCount);
List <ConversionSourceDocument> resultSourceDocuments = result.Sources.ToList();
Assert.AreEqual(sourceDocument1.RemoteWorkFile, resultSourceDocuments[0].RemoteWorkFile);
Assert.IsNull(resultSourceDocuments[0].Password);
Assert.AreEqual("1", resultSourceDocuments[0].Pages);
Assert.AreEqual(sourceDocument2.RemoteWorkFile, resultSourceDocuments[1].RemoteWorkFile);
Assert.IsNull(resultSourceDocuments[1].Password);
Assert.AreEqual("1", resultSourceDocuments[1].Pages);
await result.RemoteWorkFile.SaveAsync("output.pdf");
FileAssert.IsPdf("output.pdf");
}
private static void AssertErrorResult(ConversionResult result, string expectedErrorCode, string expectedPagesValue, ConversionSourceDocument associatedSourceDocument)
{
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.IsError);
// We want to throw if someone tries to get the RemoteWorkFile from an error result,
// because we don't want them storing null to some var and then use it much later
// only to discover they can't. So we fail fast.
Assert.ThrowsException <InvalidOperationException>(() => { var x = result.RemoteWorkFile; });
Assert.AreEqual(null, result.PageCount);
Assert.AreEqual(expectedErrorCode, result.ErrorCode);
Assert.AreEqual(1, result.Sources.Count());
Assert.AreEqual(expectedPagesValue, result.Sources.ElementAt(0).Pages);
Assert.AreEqual(associatedSourceDocument.RemoteWorkFile.FileId, result.Sources.ElementAt(0).RemoteWorkFile.FileId);
Assert.AreEqual(associatedSourceDocument.RemoteWorkFile.FileExtension, result.Sources.ElementAt(0).RemoteWorkFile.FileExtension);
}
/// <summary>
/// Perform OCR on pages of a single source document, producing a PDF.
/// <para>
/// Convenience wrapper for <see cref="ConvertAsync(IEnumerable{ConversionSourceDocument}, DestinationOptions)" />, returning a single <see cref="ConversionResult" />.
/// </para>
/// </summary>
/// <param name="sourceDocument">Information about the source document to use as input.</param>
/// <param name="options">OCR options.</param>
/// <returns>ConversionResult for the created PDF.</returns>
/// <seealso cref="ConvertAsync(ConversionSourceDocument, DestinationOptions)" />
public Task <ConversionResult> OcrToPdfAsync(ConversionSourceDocument sourceDocument, OcrOptions options) =>
this.OcrToPdfAsync(new ConversionSourceDocument[] { sourceDocument }, options);
/// <summary>
/// Perform OCR on pages of a single source document, producing a PDF.
/// <para>
/// Convenience wrapper for <see cref="ConvertAsync(IEnumerable{ConversionSourceDocument}, DestinationOptions)" />, returning a single <see cref="ConversionResult" />.
/// </para>
/// </summary>
/// <param name="sourceDocument">Information about the source document to use as input.</param>
/// <returns>ConversionResult for the created PDF.</returns>
/// <seealso cref="ConvertAsync(ConversionSourceDocument, DestinationOptions)" />
public Task <ConversionResult> OcrToPdfAsync(ConversionSourceDocument sourceDocument) =>
this.OcrToPdfAsync(sourceDocument, new OcrOptions());
public async Task Work_file_reuploading_works_correctly_and_number_of_reuploads_is_minimized()
{
// Arrange
RemoteWorkFile wf1 = await this.UploadPlainTextAsync(Util.RestClient.CreateAffinitySession(), "File 1");
RemoteWorkFile wf2 = await this.UploadPlainTextAsync(Util.RestClient.CreateAffinitySession(), "File 2");
// Make sure we get at least one distinct affinity token
int i = 2;
while (wf1.AffinityToken == wf2.AffinityToken && i < 100)
{
wf2 = await this.UploadPlainTextAsync(Util.RestClient.CreateAffinitySession(), $"File 2");
i++;
}
// Try to create some files with the same affinity
AffinitySession affinitySession = Util.RestClient.CreateAffinitySession();
RemoteWorkFile wf3 = await this.UploadPlainTextAsync(affinitySession, "File 3");
RemoteWorkFile wf4 = await this.UploadPlainTextAsync(affinitySession, "File 4");
RemoteWorkFile wf5 = await this.UploadPlainTextAsync(affinitySession, "File 5");
RemoteWorkFile wf6 = await this.UploadPlainTextAsync(affinitySession, "File 6");
RemoteWorkFile wf7 = await this.UploadPlainTextAsync(affinitySession, "File 7");
RemoteWorkFile wf8 = await this.UploadPlainTextAsync(affinitySession, "File 8");
RemoteWorkFile wf9 = await this.UploadPlainTextAsync(affinitySession, "File 9");
RemoteWorkFile wf10 = await this.UploadPlainTextAsync(affinitySession, "File 10");
var doc1 = new ConversionSourceDocument(wf1);
var doc2 = new ConversionSourceDocument(wf2);
var doc3 = new ConversionSourceDocument(wf3);
var doc4 = new ConversionSourceDocument(wf4);
var doc5 = new ConversionSourceDocument(wf5);
var doc6 = new ConversionSourceDocument(wf6);
var doc7 = new ConversionSourceDocument(wf7);
var doc8 = new ConversionSourceDocument(wf8);
var doc9 = new ConversionSourceDocument(wf9);
var doc10 = new ConversionSourceDocument(wf10);
var sourceDocuments = new[] { doc1, doc2, doc3, doc4, doc5, doc6, doc7, doc8, doc9, doc10 };
// Validate that we actually have distinct affinity
IEnumerable <string> distinctAffinityTokensBefore = sourceDocuments.Select(x => x.RemoteWorkFile.AffinityToken).Distinct();
Assert.IsTrue(distinctAffinityTokensBefore.Count() > 1);
string mostFrequentAffinityToken = sourceDocuments.GroupBy(x => x.RemoteWorkFile.AffinityToken).OrderByDescending(x => x.Count()).Select(x => x.Key).First();
// Act
ConversionResult output = await Util.CreatePrizmDocServerClient().CombineToPdfAsync(sourceDocuments);
// Assert that the ConversionSourceDocument instances all now have RemoteWorkFile instances with the same affinity token.
IEnumerable <string> distinctAffinityTokensAfter = sourceDocuments.Select(x => x.RemoteWorkFile.AffinityToken).Distinct();
Assert.AreEqual(1, distinctAffinityTokensAfter.Count());
Assert.AreEqual(mostFrequentAffinityToken, distinctAffinityTokensAfter.Single());
string outputFileText = string.Join("\n", await TextUtil.ExtractPagesText(output.RemoteWorkFile));
Assert.AreEqual(@"File 1File 2File 3File 4File 5File 6File 7File 8File 9File 10", outputFileText.Replace("\r", string.Empty).Replace("\n", string.Empty));
}
/// <summary>
/// Convert pages of a single source document to PDF.
/// <para>
/// Convenience wrapper for <see cref="ConvertAsync(IEnumerable{ConversionSourceDocument}, DestinationOptions)" />, returning a single <see cref="ConversionResult" />.
/// </para>
/// </summary>
/// <param name="sourceDocument">Information about the source document to
/// use as input.</param>
/// <param name="header">Header to be appended to each page of the output
/// document. The original page content will be left unaltered. The overall
/// page dimensions will be expanded to accommodate the header
/// content.</param>
/// <param name="footer">Footer to be appended to each page of the output
/// document. The original page content will be left unaltered. The overall
/// page dimensions will be expanded to accommodate the footer
/// content.</param>
/// <returns>ConversionResult for the created PDF.</returns>
/// <seealso cref="ConvertAsync(ConversionSourceDocument, DestinationOptions)" />
public Task <ConversionResult> ConvertToPdfAsync(ConversionSourceDocument sourceDocument, HeaderFooterOptions header = null, HeaderFooterOptions footer = null) =>
this.CombineToPdfAsync(new ConversionSourceDocument[] { sourceDocument }, header, footer);
private static void AssertSuccessResult(ConversionResult result, string expectedPagesValue, ConversionSourceDocument associatedSourceDocument, int expectedPageCount = 1)
{
Assert.IsTrue(result.IsSuccess);
Assert.IsFalse(result.IsError);
Assert.IsNotNull(result.RemoteWorkFile);
Assert.AreEqual(expectedPageCount, result.PageCount);
Assert.IsNull(result.ErrorCode);
Assert.AreEqual(expectedPagesValue, result.Sources.ElementAt(0).Pages);
Assert.AreEqual(associatedSourceDocument.RemoteWorkFile.FileId, result.Sources.ElementAt(0).RemoteWorkFile.FileId);
Assert.AreEqual(associatedSourceDocument.RemoteWorkFile.FileExtension, result.Sources.ElementAt(0).RemoteWorkFile.FileExtension);
}
