public void TestHandleUploadResponseStream()
        {
            var transactionLog    = new TransactionLogType();
            var transactionLogXml = GetXml(transactionLog);

            var stream = new MemoryStream();
            var writer = new StreamWriter(stream, Encoding.Unicode);

            writer.Write(transactionLogXml);
            writer.Flush();
            stream.Seek(0, SeekOrigin.Begin);

            var user = new User(1);
            var dto  = new SevisBatchProcessingDTO();

            dto.BatchId = "batchId";

            Action <User, string, string, IDS2019FileProvider> callback = (u, batchId, xml, fileProvider) =>
            {
                Assert.IsTrue(Object.ReferenceEquals(u, user));
                Assert.IsNotNull(fileProvider);
                Assert.IsInstanceOfType(fileProvider, typeof(NullDS2019FileProvider));
                Assert.AreEqual(transactionLogXml, xml);
                Assert.AreEqual(dto.BatchId, batchId);
            };

            service.Setup(x => x.ProcessTransactionLog(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IDS2019FileProvider>()))
            .Callback(callback);
            var handler = new ZipArchiveSevisApiResponseHandler(service.Object);

            handler.HandleUploadResponseStream(user, dto, stream);
        }
        public async Task TestHandleDownloadResponseStreamAsync()
        {
            using (ShimsContext.Create())
            {
                var transactionLog    = new TransactionLogType();
                var transactionLogXml = GetXml(transactionLog);

                var zipFileName = String.Format("{0}", SevisBatchZipArchiveHandler.TRANSACTION_LOG_FILE_NAME);
                var entry       = new System.IO.Compression.Fakes.ShimZipArchiveEntry
                {
                    NameGet = () => zipFileName,
                    Open    = () =>
                    {
                        var stream = new MemoryStream();
                        var writer = new StreamWriter(stream, Encoding.Unicode);
                        writer.Write(transactionLogXml);
                        writer.Flush();
                        stream.Seek(0, SeekOrigin.Begin);
                        return(stream);
                    }
                };

                var entries = new List <ZipArchiveEntry>();
                entries.Add(entry);
                var readonlyEntries = new ReadOnlyCollection <ZipArchiveEntry>(entries);

                var zipArchive = new System.IO.Compression.Fakes.ShimZipArchive
                {
                    EntriesGet = () => readonlyEntries,
                };

                var memoryStream = new MemoryStream();
                Func <Stream, ZipArchive> zipArchiveDelegate = (s) =>
                {
                    Assert.IsTrue(Object.ReferenceEquals(memoryStream, s));
                    return(zipArchive);
                };


                var user = new User(1);
                var dto  = new SevisBatchProcessingDTO();
                dto.BatchId = "batchId";
                var handler = new ZipArchiveSevisApiResponseHandler(service.Object, zipArchiveDelegate);
                Action <User, string, string, IDS2019FileProvider> callback = (u, batchId, xml, fileProvider) =>
                {
                    Assert.IsTrue(Object.ReferenceEquals(u, user));
                    Assert.IsNotNull(fileProvider);
                    Assert.IsInstanceOfType(fileProvider, typeof(SevisBatchZipArchiveHandler));
                    Assert.AreEqual(transactionLogXml, xml);
                    Assert.AreEqual(dto.BatchId, batchId);
                };
                service.Setup(x => x.ProcessTransactionLogAsync(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IDS2019FileProvider>()))
                .Returns(Task.FromResult <object>(null))
                .Callback(callback);

                await handler.HandleDownloadResponseStreamAsync(user, dto, memoryStream);
            }
        }
        public void TestConstructor_UseDefaultZipArchiveDelegate()
        {
            var testService   = new ZipArchiveSevisApiResponseHandler(service.Object);
            var delegateField = typeof(ZipArchiveSevisApiResponseHandler).GetField("zipArchiveDelegate", BindingFlags.NonPublic | BindingFlags.Instance);
            var delegateValue = delegateField.GetValue(testService);

            Assert.IsNotNull(delegateField);
            Assert.IsNotNull(delegateValue);
        }
        public void TestConstructor_UseGivenZipArchiveDelegate()
        {
            Func <Stream, ZipArchive> myDelegate = (s) => null;

            var testService   = new ZipArchiveSevisApiResponseHandler(service.Object, myDelegate);
            var delegateField = typeof(ZipArchiveSevisApiResponseHandler).GetField("zipArchiveDelegate", BindingFlags.NonPublic | BindingFlags.Instance);
            var delegateValue = delegateField.GetValue(testService);

            Assert.IsNotNull(delegateField);
            Assert.IsNotNull(delegateValue);
            Assert.IsTrue(Object.ReferenceEquals(myDelegate, delegateValue));
        }
        public void TestDispose_ServiceIsNotDisposable()
        {
            var disposableService = new Mock <ISevisBatchProcessingService>();
            var serviceToDispose  = new ZipArchiveSevisApiResponseHandler(disposableService.Object);

            var serviceField = typeof(ZipArchiveSevisApiResponseHandler).GetField("service", BindingFlags.NonPublic | BindingFlags.Instance);
            var serviceValue = serviceField.GetValue(serviceToDispose);

            Assert.IsNotNull(serviceField);
            Assert.IsNotNull(serviceValue);

            serviceToDispose.Dispose();
            serviceValue = serviceField.GetValue(serviceToDispose);
            Assert.IsNotNull(serviceValue);
        }