public void SendsBytesThroughDocumentBundleProcessor()
{
//Arrange
var clientConfiguration = new ClientConfiguration(Environment.DifiQa, CoreDomainUtility.GetPostenTestCertificate())
{
DocumentBundleProcessors = new List <IDocumentBundleProcessor>
{
new SimpleDocumentBundleProcessor(),
new SimpleDocumentBundleProcessor()
}
};
var job = DomainUtility.GetDirectJobWithSender();
var asiceAttachableProcessors = clientConfiguration.DocumentBundleProcessors.Select(p => new AsiceAttachableProcessor(job, p));
var asiceAttachables = new IAsiceAttachable[] { DomainUtility.GetDirectManifest(), DomainUtility.GetSignature(), DomainUtility.GetDirectDocument() };
//Act
var asiceArchive = new AsiceArchive(asiceAttachableProcessors, asiceAttachables);
asiceArchive.GetBytes();
//Assert
foreach (var simpleProcessor in clientConfiguration.DocumentBundleProcessors.Cast <SimpleDocumentBundleProcessor>())
{
Assert.True(simpleProcessor.StreamLength > 1000);
Assert.True(simpleProcessor.CouldReadBytesStream);
Assert.Equal(0, simpleProcessor.Initialposition);
}
}
public void ReturnsProperBytesCount()
{
//Arrange
var forsendelse = DomainUtility.GetDigitalDigitalPostWithNotificationMultipleDocumentsAndHigherSecurity();
var manifest = new Manifest(forsendelse);
var cryptographicCertificate = forsendelse.PostInfo.Mottaker.Sertifikat;
var signature = new Signature(forsendelse, manifest, DomainUtility.GetAvsenderCertificate());
var asiceAttachables = new List <IAsiceAttachable>();
asiceAttachables.AddRange(forsendelse.Dokumentpakke.Vedlegg);
asiceAttachables.Add(forsendelse.Dokumentpakke.Hoveddokument);
asiceAttachables.Add(manifest);
asiceAttachables.Add(signature);
var asiceArchive = new AsiceArchive(cryptographicCertificate, new GuidUtility(), new List <AsiceAttachableProcessor>(), asiceAttachables.ToArray());
var expectedBytesCount = 0L;
foreach (var dokument in asiceAttachables)
{
expectedBytesCount += dokument.Bytes.Length;
}
//Act
var actualBytesCount = asiceArchive.UnzippedContentBytesCount;
//Assert
Assert.Equal(expectedBytesCount, actualBytesCount);
}
public void InitializesFieldsProperly()
{
//Arrange
var forsendelse = DomainUtility.GetDigitalDigitalPostWithNotificationMultipleDocumentsAndHigherSecurity();
var manifest = new Manifest(forsendelse);
var cryptographicCertificate = forsendelse.PostInfo.Mottaker.Sertifikat;
var signature = new Signature(forsendelse, manifest, DomainUtility.GetAvsenderCertificate());
var asiceAttachables = new List <IAsiceAttachable>();
asiceAttachables.AddRange(forsendelse.Dokumentpakke.Vedlegg);
asiceAttachables.Add(forsendelse.Dokumentpakke.Hoveddokument);
asiceAttachables.Add(manifest);
asiceAttachables.Add(signature);
var asiceAttachablesArray = asiceAttachables.ToArray();
var asiceAttachableProcessors = new List <AsiceAttachableProcessor>();
//Act
var asiceArchive = new AsiceArchive(cryptographicCertificate, new GuidUtility(), asiceAttachableProcessors, asiceAttachablesArray);
//Assert
Assert.Equal(asiceAttachableProcessors, asiceArchive.AsiceAttachableProcessors);
Assert.Equal(asiceAttachablesArray, asiceArchive.AsiceAttachables);
}
public void SendsBytesThroughDocumentBundleProcessors()
{
//Arrange
var clientConfiguration = new Klientkonfigurasjon(Miljø.FunksjoneltTestmiljø)
{
Dokumentpakkeprosessorer = new List <IDokumentpakkeProsessor>
{
new SimpleDocumentBundleProcessor(),
new SimpleDocumentBundleProcessor()
}
};
var forsendelse = DomainUtility.GetForsendelseSimple();
var asiceAttachableProcessors = clientConfiguration.Dokumentpakkeprosessorer.Select(p => new AsiceAttachableProcessor(forsendelse, p));
var asiceAttachables = new IAsiceAttachable[] { DomainUtility.GetHoveddokumentSimple() };
//Act
var asiceArchive = new AsiceArchive(DomainUtility.GetMottakerCertificate(), new GuidUtility(), asiceAttachableProcessors, asiceAttachables);
var bytes = asiceArchive.Bytes;
//Assert
foreach (var simpleProcessor in clientConfiguration.Dokumentpakkeprosessorer.Cast <SimpleDocumentBundleProcessor>())
{
Assert.True(simpleProcessor.StreamLength > 1000);
Assert.True(simpleProcessor.CouldReadBytesStream);
Assert.Equal(0, simpleProcessor.Initialposition);
}
}
public async Task Throws_exception_on_invalid_manifest_in_attachment()
{
//Arrange
var client = GetClientWithRequestValidator(new FakeHttpClientForDataResponse());
var serializedfunc = new Func <IRequestContent, string>(p => ContentUtility.GetDirectSignatureJobRequestBody());
var manifestBytes = Encoding.UTF8.GetBytes(XmlResource.Request.GetPortalManifest().OuterXml);
var asiceArchive = new AsiceArchive(new List <AsiceAttachableProcessor>());
asiceArchive.AddAttachable("manifest.xml", manifestBytes);
var documentBundle = new DocumentBundle(asiceArchive.GetBytes());
var createAction = new CreateAction(new FakeJob(), documentBundle, serializedfunc);
//Act
await Assert.ThrowsAsync <InvalidXmlException>(async() => await client.SendAsync(GetHttpRequestMessage(createAction.Content())).ConfigureAwait(false)).ConfigureAwait(false);
//Assert
}
public void ConstructorGeneratesBytes()
{
//Arrange
var document = DomainUtility.GetDirectDocument();
var asiceArchive = new AsiceArchive(new AsiceAttachableProcessor[] { }, DomainUtility.GetDirectManifest(), DomainUtility.GetSignature(), document);
//Act
var archiveBytes = asiceArchive.GetBytes();
//Assert
using (var memoryStream = new MemoryStream(archiveBytes))
{
using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Read))
{
Assert.Contains(archive.Entries, entry => entry.FullName == "manifest.xml");
Assert.Contains(archive.Entries, entry => entry.FullName == "META-INF/signatures.xml");
Assert.Contains(archive.Entries, entry => entry.FullName == document.FileName);
}
}
}
public void AddsAttachableToZip()
{
//Arrange
var asiceArchive = new AsiceArchive(new AsiceAttachableProcessor[] { });
//Act
var attachment = DomainUtility.GetDirectDocument();
asiceArchive.AddAttachable(attachment.FileName, attachment.Bytes);
var archiveBytes = asiceArchive.GetBytes();
//Assert
using (var memoryStream = new MemoryStream(archiveBytes))
{
using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Read))
{
Assert.Contains(archive.Entries, entry => entry.FullName == attachment.FileName);
}
}
}
public void CreateArchive()
{
byte[] zippedData;
using (var zippedOutStream = new MemoryStream())
{
using (var archive = AsiceArchive.Create(
zippedOutStream,
CadesManifestCreator.CreateWithSignatureFile(),
TestdataLoader.ReadCertificatesForTest(),
MessageDigestAlgorithm.SHA256Desig))
using (var fileStream = File.OpenRead(FileNameTestPdf))
{
archive.AddEntry(
fileStream,
new FileRef(FileNameTestPdf, MimeType.ForString(MimeTypes.GetMimeType(FileNameTestPdf))));
}
zippedData = zippedOutStream.ToArray();
zippedData.Should().NotBeNull();
zippedData.Should().HaveCountGreaterThan(0);
}
using (var zipInput = new MemoryStream(zippedData))
using (var zippedArchive = new ZipArchive(zipInput, ZipArchiveMode.Read))
{
zippedArchive.Entries.Should().HaveCount(4);
zippedArchive.Entries.First(e => e.FullName.Equals(FileNameTestPdf, StringComparison.CurrentCulture)).Should().NotBeNull();
zippedArchive.Entries.First(e => e.FullName.Equals(AsiceConstants.CadesManifestFilename, StringComparison.CurrentCulture)).Should().NotBeNull();
zippedArchive.Entries.First(e => e.FullName.Equals(AsiceConstants.FileNameMimeType, StringComparison.CurrentCulture)).Should()
.NotBeNull();
var mimeTypeEntry = zippedArchive.GetEntry(AsiceConstants.FileNameMimeType);
using (var entryStream = mimeTypeEntry.Open())
using (var copyStream = new MemoryStream())
{
entryStream.CopyTo(copyStream);
Encoding.UTF8.GetString(copyStream.ToArray()).Should().Be(AsiceConstants.ContentTypeASiCe);
}
// Verifies that a CADES manifest has been generated
using (var entryStream = zippedArchive.GetEntry(AsiceConstants.CadesManifestFilename).Open())
using (var copyStream = new MemoryStream())
{
entryStream.CopyTo(copyStream);
var manifestXml = Encoding.UTF8.GetString(copyStream.ToArray());
manifestXml.Should().NotBeNull();
this.log.Info($"Manifest: {manifestXml}");
}
var signatureFile = zippedArchive.Entries
.First(e => e.FullName.StartsWith("META-INF", StringComparison.CurrentCulture) &&
e.FullName.EndsWith(".p7s", StringComparison.CurrentCulture));
signatureFile.Should().NotBeNull();
// Verifies the signature file
using (var entryStream = signatureFile.Open())
using (var copyStream = new MemoryStream())
{
entryStream.CopyTo(copyStream);
var signatureContent = copyStream.ToArray();
signatureContent.Should().HaveCountGreaterThan(0);
}
}
var tempFileName = Path.GetTempFileName();
using (var zippedStream = new MemoryStream(zippedData))
using (var outputFileStream = File.OpenWrite(tempFileName))
{
zippedStream.CopyTo(outputFileStream);
}
this.log.Info($"Wrote package to '{tempFileName}'");
}