public async Task Can_add_new_format_with_api_and_automatic_format_detection()
{
//Upload original
var handle = new DocumentHandle("Add_Format_Test");
await _documentStoreClient.UploadAsync(TestConfig.PathToOpenDocumentText, handle);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
//now add format to document.
AddFormatFromFileToDocumentModel model = new AddFormatFromFileToDocumentModel();
model.DocumentHandle = handle;
model.PathToFile = TestConfig.PathToDocumentPdf;
model.CreatedById = "office";
model.Format = null; //NO FORMAT, I want document store to be able to detect format
await _documentStoreClient.AddFormatToDocument(model, new Dictionary <String, Object>());
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
Assert.IsTrue(formats.HasFormat(new DocumentFormat("pdf")));
Assert.That(formats, Has.Count.EqualTo(2));
}
public async Task can_add_new_format_with_api()
{
//Upload original
var handle = new DocumentHandle("Add_Format_Test");
await _documentStoreClient.UploadAsync(TestConfig.PathToOpenDocumentText, handle);
// wait background projection polling
await UpdateAndWaitAsync();
//now add format to document.
AddFormatFromFileToDocumentModel model = new AddFormatFromFileToDocumentModel();
model.DocumentHandle = handle;
model.PathToFile = TestConfig.PathToTextDocument;
model.CreatedById = "tika";
model.Format = new DocumentFormat("tika");
await _documentStoreClient.AddFormatToDocument(model, new Dictionary <String, Object>());
// wait background projection polling
await UpdateAndWaitAsync();
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
Assert.IsTrue(formats.HasFormat(new DocumentFormat("tika")));
Assert.That(formats, Has.Count.EqualTo(2));
}
public async Task Add_multiple_attachment_to_existing_handle()
{
//Upload father
var fatherHandle = new DocumentHandle("father");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, fatherHandle);
await UpdateAndWaitAsync().ConfigureAwait(false);
//upload attachments
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, fatherHandle, "Content", Path.GetFileName(TestConfig.PathToDocumentPng)).ConfigureAwait(false);
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToOpenDocumentText, fatherHandle, "Content", Path.GetFileName(TestConfig.PathToOpenDocumentText)).ConfigureAwait(false);
await UpdateAndWaitAsync().ConfigureAwait(false);
var document = _documentDescriptorCollection.Find(Builders <DocumentDescriptorReadModel> .Filter.Eq("Documents", "content_1")).SingleOrDefault();
Assert.That(document, Is.Not.Null, "Document with first child handle was not find.");
document = _documentDescriptorCollection.Find(Builders <DocumentDescriptorReadModel> .Filter.Eq("Documents", "content_2")).SingleOrDefault();
Assert.That(document, Is.Not.Null, "Document with second child handle was not find.");
var handle = _documentDescriptorCollection.Find(Builders <DocumentDescriptorReadModel> .Filter.Eq("Documents", "father")).SingleOrDefault();
Assert.That(handle, Is.Not.Null, "Father Handle Not Find");
Assert.That(handle.Attachments.Select(a => a.Handle), Is.EquivalentTo(new[] { new Core.Model.DocumentHandle("content_1"), new Core.Model.DocumentHandle("content_2") }));
}
public async Task Removing_format_from_document()
{
//Upload original
var handle = new DocumentHandle("Add_Format_Test");
await _documentStoreClient.UploadAsync(TestConfig.PathToOpenDocumentText, handle);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
//now add format to document.
AddFormatFromFileToDocumentModel model = new AddFormatFromFileToDocumentModel();
model.DocumentHandle = handle;
model.PathToFile = TestConfig.PathToTextDocument;
model.CreatedById = "tika";
model.Format = new DocumentFormat("tika");
await _documentStoreClient.AddFormatToDocument(model, new Dictionary <String, Object>());
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
//now delete format
await _documentStoreClient.RemoveFormatFromDocument(handle, new DocumentFormat("tika")).ConfigureAwait(false);
await UpdateAndWaitAsync().ConfigureAwait(false);
var formats = await _documentStoreClient.GetFormatsAsync(handle).ConfigureAwait(false);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
Assert.That(formats, Has.Count.EqualTo(1), "Tika format should be removed from the projection");
//Uncomment the test if you want to verify that blob id is deleted from a projection
//Assert.Throws<Exception>(() => _blobStore.GetDescriptor(blobId), "Blob Id for artifact is not deleted");
}
public async Task attachments_not_retrieve_nested_attachment()
{
//Upload father
var fatherHandle = new DocumentHandle("father");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, fatherHandle);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, fatherHandle, "source", Path.GetFileName(TestConfig.PathToDocumentPng));
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, new DocumentHandle("source_1"), "nested", Path.GetFileName(TestConfig.PathToDocumentPng));
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
var attachments = await _documentStoreClient.GetAttachmentsAsync(fatherHandle);
Assert.NotNull(attachments);
Assert.That(attachments.Attachments.Length, Is.EqualTo(1));
Assert.That(attachments.Attachments[0].RelativePath, Is.EqualTo(Path.GetFileName(TestConfig.PathToDocumentPng)));
Assert.That(attachments.Attachments[0].Handle, Is.EqualTo("http://localhost:5123/tests/documents/source_1"));
}
public async Task Add_multiple_time_same_handle_with_same_payload()
{
//Upload father
var theHandle = new DocumentHandle("a_pdf_file");
List <Task> jobs = new List <Task>();
for (int i = 0; i < 10; i++)
{
var task = _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, theHandle);
jobs.Add(task);
}
Thread.Sleep(1000);
foreach (var job in jobs)
{
await job;
}
await UpdateAndWaitAsync().ConfigureAwait(false);
var documents = _documentDescriptorCollection.FindAll();
Assert.That(documents.Count(), Is.EqualTo(1), "We expect all document to be de-duplicated.");
var document = documents.Single();
Assert.That(document.Created, Is.True, "Document descriptor should be in created-state.");
}
public async Task attachments_fat_retrieve_nested_attachment()
{
//Upload father
var fatherHandle = new DocumentHandle("father");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, fatherHandle);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, fatherHandle, "source", Path.GetFileName(TestConfig.PathToDocumentPng));
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToExcelDocument, new DocumentHandle("source_1"), "nested", Path.GetFileName(TestConfig.PathToExcelDocument));
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
var attachments = await _documentStoreClient.GetAttachmentsFatAsync(fatherHandle);
Assert.NotNull(attachments);
Assert.That(attachments.Attachments, Has.Count.EqualTo(2));
Assert.That(attachments.Attachments.Select(a => a.FileName), Is.EquivalentTo(new[] {
Path.GetFileName(TestConfig.PathToDocumentPng),
Path.GetFileName(TestConfig.PathToExcelDocument)
}));
Assert.That(attachments.Attachments.Select(a => a.Uri),
Is.EquivalentTo(new[] {
new Uri("http://localhost:5123/tests/documents/source_1"),
new Uri("http://localhost:5123/tests/documents/nested_1")
}));
}
public async Task can_add_attachment_to_existing_handle()
{
//Upload father
var fatherHandle = new DocumentHandle("father");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, fatherHandle);
// wait background projection polling
await UpdateAndWaitAsync();
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, fatherHandle, "Content", Path.GetFileName(TestConfig.PathToDocumentPng));
// wait background projection polling
await UpdateAndWaitAsync();
var document = _documentDescriptorCollection.Find(Builders <DocumentDescriptorReadModel> .Filter.Eq("Documents", "content_1")).SingleOrDefault();
Assert.That(document, Is.Not.Null, "Document with child handle was not find.");
var handle = _documentDescriptorCollection.Find(Builders <DocumentDescriptorReadModel> .Filter.Eq("Documents", "father")).SingleOrDefault();
Assert.That(handle, Is.Not.Null, "Father Handle Not Find");
Assert.That(handle.Attachments.Select(a => a.Handle), Is.EquivalentTo(new[] {
new Jarvis.DocumentStore.Core.Model.DocumentHandle("content_1")
}));
}
public async Task can_upload_document_with_name_greater_than_250_char()
{
var handle = DocumentHandle.FromString("Pdf_3");
String longFileName = Path.Combine(
Path.GetTempPath(),
"_lfn" + new string('X', 240) + ".pdf");
if (!File.Exists(longFileName))
{
File.Copy(TestConfig.PathToDocumentPdf, longFileName);
}
await _documentStoreClient.UploadAsync(longFileName, handle);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
// check readmodel
var tenantAccessor = ContainerAccessor.Instance.Resolve <ITenantAccessor>();
var tenant = tenantAccessor.GetTenant(new TenantId(TestConfig.Tenant));
var docReader = tenant.Container.Resolve <IMongoDbReader <DocumentDescriptorReadModel, DocumentDescriptorId> >();
var allDocuments = docReader.AllUnsorted.Count();
Assert.AreEqual(1, allDocuments);
}
public async Task Should_get_info_without_content()
{
var documentHandle = DocumentHandle.FromString("Pdf_2");
await _documentStoreClient.UploadAsync(
TestConfig.PathToDocumentPdf,
documentHandle
);
// waits for storage
await UpdateAndWaitAsync().ConfigureAwait(false);
var format = new DocumentFormat("original");
var options = new OpenOptions()
{
FileName = "pluto.pdf",
SkipContent = true
};
var reader = _documentStoreClient.OpenRead(documentHandle, format, options);
using (var downloaded = new MemoryStream())
{
await(await reader.OpenStream()).CopyToAsync(downloaded);
Assert.AreEqual(0, downloaded.Length);
Assert.AreEqual(72768, reader.ContentLength);
}
}
public async Task Should_upload_and_download_original_format()
{
await _documentStoreClient.UploadAsync(
TestConfig.PathToDocumentPdf,
DocumentHandle.FromString("Pdf_2"),
new Dictionary <string, object> {
{ "callback", "http://localhost/demo" }
}
);
// waits for storage
await UpdateAndWaitAsync().ConfigureAwait(false);
var reader = _documentStoreClient.OpenRead(DocumentHandle.FromString("Pdf_2"));
using (var downloaded = new MemoryStream())
using (var uploaded = new MemoryStream())
{
using (var fileStream = File.OpenRead(TestConfig.PathToDocumentPdf))
{
await fileStream.CopyToAsync(uploaded).ConfigureAwait(false);
}
await(await reader.OpenStream()).CopyToAsync(downloaded);
Assert.IsTrue(CompareMemoryStreams(uploaded, downloaded));
}
}
internal DocumentImportData(Uri uri,string fileName, DocumentHandle handle, DocumentFormat format, string tenant, Guid taskId)
{
TaskId = taskId;
Uri = uri;
FileName = fileName;
Handle = handle;
Format = format;
Tenant = tenant;
}
public async Task Should_get_document_formats()
{
var handle = new DocumentHandle("Formats");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, handle);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
}
public async Task adding_two_time_same_format_overwrite_older()
{
//Upload original
var handle = new DocumentHandle("Add_Format_Test");
await _documentStoreClient.UploadAsync(TestConfig.PathToOpenDocumentText, handle);
// wait background projection polling
await UpdateAndWaitAsync();
//now add format to document.
AddFormatFromFileToDocumentModel model = new AddFormatFromFileToDocumentModel();
model.DocumentHandle = handle;
model.PathToFile = TestConfig.PathToTextDocument;
model.CreatedById = "tika";
model.Format = new DocumentFormat("tika");
await _documentStoreClient.AddFormatToDocument(model, new Dictionary <String, Object>());
// wait background projection polling
await UpdateAndWaitAsync();
//get blobId of the original format
var descriptor = _documentDescriptorCollection.FindAll().Single();
BlobId blobId = descriptor.Formats
.Single(f => f.Key == new DocumentFormat("tika"))
.Value.BlobId;
//now add same format with different content.
model = new AddFormatFromFileToDocumentModel();
model.DocumentHandle = handle;
model.PathToFile = TestConfig.PathToHtml;
model.CreatedById = "tika";
model.Format = new DocumentFormat("tika");
await _documentStoreClient.AddFormatToDocument(model, new Dictionary <String, Object>());
// wait background projection polling
await UpdateAndWaitAsync();
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
Assert.IsTrue(formats.HasFormat(new DocumentFormat("tika")));
Assert.That(formats, Has.Count.EqualTo(2));
await CompareDownloadedStreamToFile(TestConfig.PathToHtml, _documentStoreClient.OpenRead(handle, new DocumentFormat("tika")));
//verify old blob storage was deleted
//Assert.Throws<Exception>(() => _blobStore.GetDescriptor(blobId), "Blob Id for artifact is not deleted");
}
public async Task Should_download_with_range_header()
{
var documentHandle = DocumentHandle.FromString("Pdf_2");
await _documentStoreClient.UploadAsync(
TestConfig.PathToDocumentPdf,
documentHandle
);
// waits for storage
await UpdateAndWaitAsync().ConfigureAwait(false);
var format = new DocumentFormat("original");
var options = new OpenOptions()
{
FileName = "pluto.pdf",
RangeFrom = 0,
RangeTo = 199
};
var reader = _documentStoreClient.OpenRead(documentHandle, format, options);
using (var downloaded = new MemoryStream())
{
await(await reader.OpenStream()).CopyToAsync(downloaded);
Assert.AreEqual(200, downloaded.Length, "Wrong range support");
Assert.AreEqual(200, reader.ContentLength);
Assert.AreEqual("bytes 0-199/72768", reader.ReponseHeaders[HttpResponseHeader.ContentRange]);
}
//load without rangeto
options = new OpenOptions()
{
FileName = "pluto.pdf",
RangeFrom = 200
};
reader = _documentStoreClient.OpenRead(documentHandle, format, options);
using (var downloaded = new MemoryStream())
{
await(await reader.OpenStream()).CopyToAsync(downloaded);
Assert.AreEqual(72768 - 200, downloaded.Length, "Wrong range support");
Assert.AreEqual(72768 - 200, reader.ContentLength);
Assert.AreEqual("bytes 200-72767/72768", reader.ReponseHeaders[HttpResponseHeader.ContentRange]);
}
}
public async Task Should_upload_with_a_stream()
{
var handle = DocumentHandle.FromString("Pdf_4");
using (var stream = File.OpenRead(TestConfig.PathToDocumentPdf))
{
var response = await _documentStoreClient.UploadAsync(
"demo.pdf",
handle,
stream
);
Assert.AreEqual("8fe8386418f85ef4ee8ef1f3f1117928", response.Hash);
Assert.AreEqual("md5", response.HashType);
Assert.AreEqual("http://localhost:5123/tests/documents/pdf_4", response.Uri);
}
}
public async Task Should_upload_file_with_custom_data()
{
var response = await _documentStoreClient.UploadAsync(
TestConfig.PathToDocumentPdf,
DocumentHandle.FromString("Pdf_1"),
new Dictionary <string, object> {
{ "callback", "http://localhost/demo" }
}
);
Assert.AreEqual("8fe8386418f85ef4ee8ef1f3f1117928", response.Hash);
Assert.AreEqual("md5", response.HashType);
Assert.AreEqual("http://localhost:5123/tests/documents/pdf_1", response.Uri);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
var customData = await _documentStoreClient.GetCustomDataAsync(DocumentHandle.FromString("Pdf_1"));
Assert.NotNull(customData);
Assert.IsTrue(customData.ContainsKey("callback"));
Assert.AreEqual("http://localhost/demo", customData["callback"]);
}
public async Task add_multiple_attachment_to_existing_handle_then_delete_handle()
{
//Upload father
var fatherHandle = new DocumentHandle("father");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, fatherHandle);
await UpdateAndWaitAsync().ConfigureAwait(false);
//upload attachments
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, fatherHandle, "Zip", Path.GetFileName(TestConfig.PathToDocumentPng));
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToOpenDocumentText, fatherHandle, "Zip", Path.GetFileName(TestConfig.PathToOpenDocumentText));
await UpdateAndWaitAsync().ConfigureAwait(false);
await _documentStoreClient.DeleteAsync(fatherHandle);
await UpdateAndWaitAsync().ConfigureAwait(false);
Assert.That(_documentDescriptorCollection.AsQueryable().Count(), Is.EqualTo(0), "Attachment should be deleted.");
Assert.That(_documentCollection.AsQueryable().Count(), Is.EqualTo(0), "Attachment should be deleted.");
}
public async Task Can_add_new_format_with_api_from_object()
{
//Upload original
var handle = new DocumentHandle("Add_Format_Test");
await _documentStoreClient.UploadAsync(TestConfig.PathToOpenDocumentText, handle);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
DocumentContent content = new DocumentContent(new DocumentContent.DocumentPage[]
{
new DocumentContent.DocumentPage(1, "TEST"),
}, new DocumentContent.MetadataHeader[] { });
//now add format to document.
AddFormatFromObjectToDocumentModel model = new AddFormatFromObjectToDocumentModel();
model.DocumentHandle = handle;
model.StringContent = JsonConvert.SerializeObject(content);
model.CreatedById = "tika";
model.FileName = "add_format_test.content";
model.Format = new DocumentFormat("content");
await _documentStoreClient.AddFormatToDocument(model, new Dictionary <String, Object>());
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
Assert.IsTrue(formats.HasFormat(new DocumentFormat("content")));
Assert.That(formats, Has.Count.EqualTo(2));
await CompareDownloadedStreamToStringContent(
model.StringContent,
_documentStoreClient.OpenRead(handle, new DocumentFormat("content")));
}
public async Task should_upload_get_metadata_and_delete_a_document()
{
var handle = DocumentHandle.FromString("Pdf_3");
await _documentStoreClient.UploadAsync(
TestConfig.PathToDocumentPdf,
handle,
new Dictionary <string, object> {
{ "callback", "http://localhost/demo" }
}
);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
var data = await _documentStoreClient.GetCustomDataAsync(handle);
await _documentStoreClient.DeleteAsync(handle);
await UpdateAndWaitAsync().ConfigureAwait(false);
var ex = Assert.ThrowsAsync <HttpRequestException>(async() =>
{
await _documentStoreClient.GetCustomDataAsync(handle).ConfigureAwait(false);
});
Assert.IsTrue(ex.Message.Contains("404"));
// check readmodel
var tenantAccessor = ContainerAccessor.Instance.Resolve <ITenantAccessor>();
var tenant = tenantAccessor.GetTenant(new TenantId(TestConfig.Tenant));
var docReader = tenant.Container.Resolve <IMongoDbReader <DocumentDescriptorReadModel, DocumentDescriptorId> >();
var allDocuments = docReader.AllUnsorted.Count();
Assert.AreEqual(0, allDocuments);
}
public async Task upload_copy_handle_then_delete_original_handle()
{
var handle = DocumentHandle.FromString("PdfHandleToCopy");
var copiedHandle = DocumentHandle.FromString("PdfHandleCopied");
await _documentStoreClient.UploadAsync(
TestConfig.PathToDocumentPdf,
handle,
new Dictionary <string, object> {
{ "callback", "http://localhost/demo" }
}
);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
await _documentStoreClient.CopyHandleAsync(handle, copiedHandle);
await UpdateAndWaitAsync().ConfigureAwait(false);
await _documentStoreClient.DeleteAsync(handle);
await UpdateAndWaitAsync().ConfigureAwait(false);
// check readmodel
var tenantAccessor = ContainerAccessor.Instance.Resolve <ITenantAccessor>();
var tenant = tenantAccessor.GetTenant(new TenantId(TestConfig.Tenant));
var docReader = tenant.Container.Resolve <IMongoDbReader <DocumentDescriptorReadModel, DocumentDescriptorId> >();
var allDocuments = docReader.AllUnsorted;
Assert.AreEqual(1, allDocuments.Count());
var singleDoc = docReader.AllUnsorted.Single();
Assert.That(singleDoc.Documents.Select(h => h.ToString()), Is.EquivalentTo(new[] { copiedHandle.ToString() }));
}
public async void adding_two_time_same_format_overwrite_older()
{
//Upload original
var handle = new DocumentHandle("Add_Format_Test");
await _documentStoreClient.UploadAsync(TestConfig.PathToOpenDocumentText, handle);
// wait background projection polling
await UpdateAndWaitAsync();
//now add format to document.
AddFormatFromFileToDocumentModel model = new AddFormatFromFileToDocumentModel();
model.DocumentHandle = handle;
model.PathToFile = TestConfig.PathToTextDocument;
model.CreatedById = "tika";
model.Format = new DocumentFormat("tika");
await _documentStoreClient.AddFormatToDocument(model, new Dictionary<String, Object>());
// wait background projection polling
await UpdateAndWaitAsync();
//get blobId of the original format
var descriptor = _documentDescriptorCollection.FindAll().Single();
var blobId = descriptor.Formats
.Where(f => f.Key == new DocumentFormat("tika"))
.Single().Value.BlobId;
//now add same format with different content.
model = new AddFormatFromFileToDocumentModel();
model.DocumentHandle = handle;
model.PathToFile = TestConfig.PathToHtml;
model.CreatedById = "tika";
model.Format = new DocumentFormat("tika");
await _documentStoreClient.AddFormatToDocument(model, new Dictionary<String, Object>());
// wait background projection polling
await UpdateAndWaitAsync();
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
Assert.IsTrue(formats.HasFormat(new DocumentFormat("tika")));
Assert.That(formats, Has.Count.EqualTo(2));
await CompareDownloadedStreamToFile(TestConfig.PathToHtml, _documentStoreClient.OpenRead(handle, new DocumentFormat("tika")));
//verify old blob storage was deleted
//Assert.Throws<Exception>(() => _blobStore.GetDescriptor(blobId), "Blob Id for artifact is not deleted");
}
public async void can_add_new_format_with_api_and_automatic_format_detection()
{
//Upload original
var handle = new DocumentHandle("Add_Format_Test");
await _documentStoreClient.UploadAsync(TestConfig.PathToOpenDocumentText, handle);
// wait background projection polling
await UpdateAndWaitAsync();
//now add format to document.
AddFormatFromFileToDocumentModel model = new AddFormatFromFileToDocumentModel();
model.DocumentHandle = handle;
model.PathToFile = TestConfig.PathToDocumentPdf;
model.CreatedById = "office";
model.Format = null; //NO FORMAT, I want document store to be able to detect format
await _documentStoreClient.AddFormatToDocument(model, new Dictionary<String, Object>());
// wait background projection polling
await UpdateAndWaitAsync();
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
Assert.IsTrue(formats.HasFormat(new DocumentFormat("pdf")));
Assert.That(formats, Has.Count.EqualTo(2));
}
public async void should_get_document_formats()
{
var handle = new DocumentHandle("Formats");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, handle);
// wait background projection polling
await UpdateAndWaitAsync();
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
}
public async void can_add_new_format_with_api_from_object()
{
//Upload original
var handle = new DocumentHandle("Add_Format_Test");
await _documentStoreClient.UploadAsync(TestConfig.PathToOpenDocumentText, handle);
// wait background projection polling
await UpdateAndWaitAsync();
DocumentContent content = new DocumentContent(new DocumentContent.DocumentPage[]
{
new DocumentContent.DocumentPage(1, "TEST"),
}, new DocumentContent.MetadataHeader[] { });
//now add format to document.
AddFormatFromObjectToDocumentModel model = new AddFormatFromObjectToDocumentModel();
model.DocumentHandle = handle;
model.StringContent = JsonConvert.SerializeObject(content);
model.CreatedById = "tika";
model.FileName = "add_format_test.content";
model.Format = new DocumentFormat("content");
await _documentStoreClient.AddFormatToDocument(model, new Dictionary<String, Object>());
// wait background projection polling
await UpdateAndWaitAsync();
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
Assert.IsTrue(formats.HasFormat(new DocumentFormat("content")));
Assert.That(formats, Has.Count.EqualTo(2));
await CompareDownloadedStreamToStringContent(
model.StringContent,
_documentStoreClient.OpenRead(handle, new DocumentFormat("content")));
}
public async void add_multiple_attachment_to_existing_handle_then_delete_handle()
{
//Upload father
var fatherHandle = new DocumentHandle("father");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, fatherHandle);
await UpdateAndWaitAsync();
//upload attachments
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, fatherHandle, "Zip", Path.GetFileName(TestConfig.PathToDocumentPng));
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToOpenDocumentText, fatherHandle, "Zip", Path.GetFileName(TestConfig.PathToOpenDocumentText));
await UpdateAndWaitAsync();
await _documentStoreClient.DeleteAsync(fatherHandle);
await UpdateAndWaitAsync();
Assert.That(_documentDescriptorCollection.AsQueryable().Count(), Is.EqualTo(0), "Attachment should be deleted.");
Assert.That(_documentCollection.AsQueryable().Count(), Is.EqualTo(0), "Attachment should be deleted.");
}
public async void removing_format_from_document()
{
//Upload original
var handle = new DocumentHandle("Add_Format_Test");
await _documentStoreClient.UploadAsync(TestConfig.PathToOpenDocumentText, handle);
// wait background projection polling
await UpdateAndWaitAsync();
//now add format to document.
AddFormatFromFileToDocumentModel model = new AddFormatFromFileToDocumentModel();
model.DocumentHandle = handle;
model.PathToFile = TestConfig.PathToTextDocument;
model.CreatedById = "tika";
model.Format = new DocumentFormat("tika");
await _documentStoreClient.AddFormatToDocument(model, new Dictionary<String, Object>());
// wait background projection polling
await UpdateAndWaitAsync();
//now get the blob for the format
var descriptor = _documentDescriptorCollection.FindAll().Single();
var blobId = descriptor.Formats
.Where(f => f.Key == new DocumentFormat("tika"))
.Single().Value.BlobId;
//now delete format
await _documentStoreClient.RemoveFormatFromDocument(handle, new DocumentFormat("tika"));
await UpdateAndWaitAsync();
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
Assert.That(formats, Has.Count.EqualTo(1), "Tika format should be removed from the projection");
//Uncomment the test if you want to verify that blob id is deleted from a projection
//Assert.Throws<Exception>(() => _blobStore.GetDescriptor(blobId), "Blob Id for artifact is not deleted");
}
public async void attachments_fat_retrieve_nested_attachment()
{
//Upload father
var fatherHandle = new DocumentHandle("father");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, fatherHandle);
// wait background projection polling
await UpdateAndWaitAsync();
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, fatherHandle, "source", Path.GetFileName(TestConfig.PathToDocumentPng));
// wait background projection polling
await UpdateAndWaitAsync();
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToExcelDocument, new DocumentHandle("source_1"), "nested", Path.GetFileName(TestConfig.PathToExcelDocument));
// wait background projection polling
await UpdateAndWaitAsync();
var attachments = await _documentStoreClient.GetAttachmentsFatAsync(fatherHandle);
Assert.NotNull(attachments);
Assert.That(attachments.Attachments, Has.Count.EqualTo(2));
Assert.That(attachments.Attachments.Select(a => a.FileName), Is.EquivalentTo(new[] {
Path.GetFileName(TestConfig.PathToDocumentPng),
Path.GetFileName(TestConfig.PathToExcelDocument)
}));
Assert.That(attachments.Attachments.Select(a => a.Uri),
Is.EquivalentTo(new[] {
new Uri("http://localhost:5123/tests/documents/source_1"),
new Uri("http://localhost:5123/tests/documents/nested_1")
}));
}
private async Task<string> GetfileNameFromHandle(DocumentStoreServiceClient client, DocumentHandle handle)
{
try
{
return await client.GetFileNameAsync(handle);
}
catch (Exception)
{
return String.Empty;
}
}
public async void add_multiple_attachment_to_existing_handle()
{
//Upload father
var fatherHandle = new DocumentHandle("father");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, fatherHandle);
await UpdateAndWaitAsync();
//upload attachments
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, fatherHandle, "Content", Path.GetFileName(TestConfig.PathToDocumentPng));
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToOpenDocumentText, fatherHandle, "Content", Path.GetFileName(TestConfig.PathToOpenDocumentText));
await UpdateAndWaitAsync();
var document = _documentDescriptorCollection.Find(Builders<DocumentDescriptorReadModel>.Filter.Eq("Documents", "content_1")).SingleOrDefault();
Assert.That(document, Is.Not.Null, "Document with first child handle was not find.");
document = _documentDescriptorCollection.Find(Builders<DocumentDescriptorReadModel>.Filter.Eq("Documents", "content_2")).SingleOrDefault();
Assert.That(document, Is.Not.Null, "Document with second child handle was not find.");
var handle = _documentDescriptorCollection.Find(Builders<DocumentDescriptorReadModel>.Filter.Eq("Documents", "father")).SingleOrDefault();
Assert.That(handle, Is.Not.Null, "Father Handle Not Find");
Assert.That(handle.Attachments.Select(a => a.Handle), Is.EquivalentTo(new[] { new Core.Model.DocumentHandle("content_1"), new Core.Model.DocumentHandle("content_2") }));
}
public async void add_multiple_time_same_handle_with_same_payload()
{
//Upload father
var theHandle = new DocumentHandle("a_pdf_file");
List<Task> jobs = new List<Task>();
for (int i = 0; i < 10; i++)
{
var task = _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, theHandle);
jobs.Add(task);
}
Thread.Sleep(1000);
foreach (var job in jobs)
{
await job;
}
await UpdateAndWaitAsync();
var documents = _documentDescriptorCollection.FindAll();
Assert.That(documents.Count(), Is.EqualTo(1), "We expect all document to be de-duplicated.");
var document = documents.Single();
Assert.That(document.Created, Is.True, "Document descriptor should be in created-state.");
}
protected async override Task<ProcessResult> OnPolling(
Shared.Jobs.PollerJobParameters parameters,
string workingFolder)
{
var client = GetDocumentStoreClient(parameters.TenantId);
var handles = parameters.All["documentList"].Split('|');
var destinationHandle = parameters.All["resultingDocumentHandle"];
var destinationFileName = parameters.All["resultingDocumentFileName"];
if (!destinationFileName.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase))
{
destinationFileName = Path.ChangeExtension(destinationFileName, ".pdf");
}
List<FileToComposeData> files = new List<FileToComposeData>();
foreach (var handle in handles)
{
var documentHandle = new DocumentHandle(handle);
Boolean pdfExists = false;
try
{
var pdfData = client.OpenRead(documentHandle, DocumentFormats.Pdf);
var tempFile = Path.Combine(workingFolder, Guid.NewGuid() + ".pdf");
using (var downloaded = new FileStream(tempFile, FileMode.OpenOrCreate, FileAccess.Write))
{
var stream = await pdfData.OpenStream();
stream.CopyTo(downloaded);
}
files.Add(FileToComposeData.FromDownloadedPdf(tempFile, handle));
pdfExists = true;
}
catch (System.Net.WebException ex)
{
Logger.WarnFormat("Handle {0} has no PDF format", handle);
}
if (!pdfExists)
{
//need to check if this file has some job pending.
var pendingJobs = await client.GetPendingJobsAsync(documentHandle);
if (pendingJobs.Length > 0)
{
//some job is still executing, probably pdf format could be generated in the future
return new ProcessResult(TimeSpan.FromSeconds(10));
}
else
{
//This file has no pdf format, mark as missing pdf.
var fileName = await GetfileNameFromHandle(client, documentHandle);
files.Add(FileToComposeData.NoPdfFormat(handle, fileName));
}
}
}
//now compose everything.
PdfManipulator manipulator = new PdfManipulator(Logger); //Create a manipulator
foreach (var fileToCompose in files)
{
String pdfFileToAppend = fileToCompose.PdfFileName;
if (!fileToCompose.HasPdfFormat)
{
pdfFileToAppend = GeneratePlaceholderFile(workingFolder, fileToCompose.FileName, fileToCompose.DocumentHandle);
}
var error = manipulator.AppendDocumentAtEnd(pdfFileToAppend);
if (!String.IsNullOrEmpty(error))
{
throw new ApplicationException(String.Format("Unable to compose file {0} error {1}", fileToCompose.DocumentHandle, error));
}
}
manipulator.AddPageNumber();
String outputDirectory = Path.Combine(workingFolder, Guid.NewGuid().ToString());
Directory.CreateDirectory(outputDirectory);
var finalFileName = Path.Combine(outputDirectory, destinationFileName);
manipulator.Save(finalFileName);
var result = await client.UploadAsync(finalFileName, new DocumentHandle(destinationHandle));
return ProcessResult.Ok;
}
public async void attachments_not_retrieve_nested_attachment()
{
//Upload father
var fatherHandle = new DocumentHandle("father");
await _documentStoreClient.UploadAsync(TestConfig.PathToDocumentPdf, fatherHandle);
// wait background projection polling
await UpdateAndWaitAsync();
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, fatherHandle, "source", Path.GetFileName(TestConfig.PathToDocumentPng));
// wait background projection polling
await UpdateAndWaitAsync();
await _documentStoreClient.UploadAttachmentAsync(TestConfig.PathToDocumentPng, new DocumentHandle("source_1"), "nested", Path.GetFileName(TestConfig.PathToDocumentPng));
// wait background projection polling
await UpdateAndWaitAsync();
var attachments = await _documentStoreClient.GetAttachmentsAsync(fatherHandle);
Assert.NotNull(attachments);
Assert.That(attachments.Attachments.Length, Is.EqualTo(1));
Assert.That(attachments.Attachments[0].RelativePath.ToString(), Is.EqualTo(Path.GetFileName(TestConfig.PathToDocumentPng)));
Assert.That(attachments.Attachments[0].Handle.ToString(), Is.EqualTo("http://localhost:5123/tests/documents/source_1"));
}