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);
                }
            }
Пример #2
0
            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);
                    }
                }
            }