コード例 #1
0
 public PrintRequestCommand(
     ILogger <PrintRequestCommand> logger,
     IPrintCreator printCreator,
     IBatchService batchService,
     IScheduleService scheduleService,
     INotificationService notificationService,
     IExternalBlobFileTransferClient externalFileTransferClient,
     IInternalBlobFileTransferClient internalFileTransferClient,
     IOptions <PrintRequestOptions> options)
 {
     _logger                     = logger;
     _printCreator               = printCreator;
     _batchService               = batchService;
     _scheduleService            = scheduleService;
     _notificationService        = notificationService;
     _externalFileTransferClient = externalFileTransferClient;
     _internalFileTransferClient = internalFileTransferClient;
     _options                    = options?.Value;
 }
コード例 #2
0
        public void Arrange(bool batchWithCertificates = true)
        {
            _mockLogger                     = new Mock <ILogger <Domain.Print.PrintRequestCommand> >();
            _mockPrintCreator               = new Mock <IPrintCreator>();
            _mockBatchService               = new Mock <IBatchService>();
            _mockScheduleService            = new Mock <IScheduleService>();
            _mockNotificationService        = new Mock <INotificationService>();
            _mockExternalFileTransferClient = new Mock <IExternalBlobFileTransferClient>();
            _mockInternalFileTransferClient = new Mock <IInternalBlobFileTransferClient>();
            _mockOptions                    = new Mock <IOptions <PrintRequestOptions> >();
            _mockMessageQueue               = new Mock <ICollector <string> >();

            _options = new PrintRequestOptions
            {
                Directory            = "MockPrintRequestDirectory",
                ArchiveDirectory     = "MockArchivePrintRequestDirectory",
                AddReadyToPrintLimit = 50
            };

            _mockOptions
            .Setup(m => m.Value)
            .Returns(_options);

            _uploadedFiles = new List <string>();
            var generator = new RandomGenerator();

            for (int i = 0; i < 10; i++)
            {
                var filename = $"PrintBatch-12{i}-{generator.Next(DateTime.Now.AddDays(-100), DateTime.Now.AddDays(100)).ToString("ddMMyyHHmm")}.json";
                _uploadedFiles.Add(filename);

                _mockExternalFileTransferClient
                .Setup(m => m.DownloadFile($"{_options.Directory}/{filename}"))
                .ReturnsAsync(JsonConvert.SerializeObject(new BatchResponse {
                    Batch = new BatchDataResponse {
                        BatchNumber = _batchNumberWithCertificates.ToString(), BatchDate = DateTime.Now
                    }
                }));
            }
            ;

            _mockExternalFileTransferClient
            .Setup(m => m.GetFileNames(It.IsAny <string>(), false))
            .ReturnsAsync(_uploadedFiles);

            _mockScheduleService
            .Setup(m => m.Get())
            .ReturnsAsync(new Schedule {
                Id = _scheduleId, RunTime = DateTime.Now
            });

            _certificates = Builder <Certificate>
                            .CreateListOfSize(10)
                            .All()
                            .Build() as List <Certificate>;

            _mockPrintCreator
            .Setup(m => m.Create(It.IsAny <int>(), It.IsAny <List <Certificate> >()))
            .Returns(new PrintOutput()
            {
                Batch     = Builder <BatchData> .CreateNew().Build(),
                PrintData = Builder <PrintData> .CreateListOfSize(10).All().Build() as List <PrintData>
            });


            _batchWithCertificatesId = Guid.NewGuid();
            _batchWithCertificates   = new Batch {
                Id = _batchWithCertificatesId, BatchNumber = _batchNumberWithCertificates, Certificates = _certificates
            };

            _batchWithoutCertificatesId = Guid.NewGuid();
            _batchWithoutCertificates   = new Batch {
                Id = _batchWithoutCertificatesId, BatchNumber = _batchNumberWithoutCertificates, Certificates = new List <Certificate>()
            };

            if (batchWithCertificates)
            {
                _mockBatchService
                .Setup(m => m.Get(_batchNumberWithCertificates))
                .ReturnsAsync(_batchWithCertificates);

                _mockBatchService
                .Setup(m => m.GetCertificatesForBatchNumber(_batchNumberWithCertificates))
                .ReturnsAsync(_batchWithCertificates.Certificates);

                _mockBatchService
                .Setup(m => m.BuildPrintBatchReadyToPrint(It.IsAny <DateTime>(), It.IsAny <int>()))
                .ReturnsAsync(_batchWithCertificates);
            }
            else
            {
                _mockBatchService
                .Setup(m => m.Get(_batchNumberWithoutCertificates))
                .ReturnsAsync(_batchWithoutCertificates);

                _mockBatchService
                .Setup(m => m.GetCertificatesForBatchNumber(_batchNumberWithoutCertificates))
                .ReturnsAsync(_batchWithoutCertificates.Certificates);

                _mockBatchService
                .Setup(m => m.BuildPrintBatchReadyToPrint(It.IsAny <DateTime>(), It.IsAny <int>()))
                .ReturnsAsync(_batchWithoutCertificates);
            }

            _sut = new Domain.Print.PrintRequestCommand(
                _mockLogger.Object,
                _mockPrintCreator.Object,
                _mockBatchService.Object,
                _mockScheduleService.Object,
                _mockNotificationService.Object,
                _mockExternalFileTransferClient.Object,
                _mockInternalFileTransferClient.Object,
                _mockOptions.Object
                );
        }