public void Arrange()
        {
            _mediator = new Mock <IMediator>();
            _mediator.Setup(x => x.Send(It.Is <GetCommitmentQueryRequest>(req => req.CommitmentId == CohortId && req.ProviderId == ProviderId), It.IsAny <CancellationToken>()))
            .ReturnsAsync(() => new GetCommitmentQueryResponse
            {
                Commitment = new CommitmentView
                {
                    EmployerAccountId = AccountId,
                    EditStatus        = EditStatus.ProviderOnly,
                    AgreementStatus   = AgreementStatus.NotAgreed
                }
            });

            var bulkUploader = new BulkUploader(_mediator.Object, Mock.Of <IBulkUploadValidator>(),
                                                Mock.Of <IBulkUploadFileParser>(), Mock.Of <IProviderCommitmentsLogger>());

            _reservationsService = new Mock <IReservationsService>();

            _mockHashingService = new Mock <IHashingService>();
            _mockHashingService.Setup(hs => hs.DecodeValue(HashedCohortId)).Returns(CohortId);

            _mockBulkUploadFileParser = new Mock <IBulkUploadFileParser>();

            _bulkUploadOrchestrator = new BulkUploadOrchestrator(
                _mediator.Object,
                bulkUploader,
                _mockHashingService.Object,
                new BulkUploadMapper(_mediator.Object),
                Mock.Of <IProviderCommitmentsLogger>(),
                _mockBulkUploadFileParser.Object,
                _reservationsService.Object);
        }
Esempio n. 2
0
        public void Arrange()
        {
            _commitmentView = new CommitmentView
            {
                EditStatus      = EditStatus.ProviderOnly,
                AgreementStatus = AgreementStatus.NotAgreed
            };

            _mediator = new Mock <IMediator>();
            _mediator.Setup(x => x.Send(It.IsAny <GetCommitmentQueryRequest>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(() => new GetCommitmentQueryResponse
            {
                Commitment = _commitmentView
            });

            _reservationsService = new Mock <IReservationsService>();
            _reservationsService.Setup(rs => rs.IsAutoReservationEnabled(It.IsAny <long>(), It.IsAny <long?>())).ReturnsAsync(true);

            var bulkUploader = new BulkUploader(_mediator.Object, Mock.Of <IBulkUploadValidator>(),
                                                Mock.Of <IBulkUploadFileParser>(), Mock.Of <IProviderCommitmentsLogger>());

            _bulkUploadOrchestrator = new BulkUploadOrchestrator(
                _mediator.Object,
                bulkUploader,
                Mock.Of <IHashingService>(),
                new BulkUploadMapper(_mediator.Object),
                Mock.Of <IProviderCommitmentsLogger>(),
                Mock.Of <IBulkUploadFileParser>(),
                _reservationsService.Object
                );
        }
        public void Setup()
        {
            var mockHashingService = new Mock <IHashingService>();

            mockHashingService.Setup(x => x.DecodeValue(It.IsAny <string>())).Returns(123L);

            _file = new Mock <HttpPostedFileBase>();
            _file.Setup(m => m.FileName).Returns("APPDATA-20051030-213855.csv");
            _file.Setup(m => m.ContentLength).Returns(400);

            _mockMediator = new Mock <IMediator>();

            _mockMediator.Setup(m => m.Send(It.IsAny <GetTrainingProgrammesQueryRequest>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(new GetTrainingProgrammesQueryResponse {
                TrainingProgrammes = new List <TrainingProgramme>
                {
                    {
                        new TrainingProgramme {
                            CourseCode = "2", Name = "Hej"
                        }
                    },
                    {
                        new TrainingProgramme {
                            CourseCode = "1-2-3"
                        }
                    }
                }
            });

            _mockMediator.Setup(m => m.Send(It.IsAny <GetOverlappingApprenticeshipsQueryRequest>(), It.IsAny <CancellationToken>()))
            .Returns(
                Task.Run(() => new GetOverlappingApprenticeshipsQueryResponse
            {
                Overlaps = new List <ApprenticeshipOverlapValidationResult>()
            }));

            _mockReservationsService = new Mock <IReservationsService>();
            _mockReservationsService.Setup(rs => rs.IsAutoReservationEnabled(It.IsAny <long>(), It.IsAny <long?>())).ReturnsAsync(true);

            var uploadValidator = BulkUploadTestHelper.GetBulkUploadValidator(512);

            _logger = new Mock <IProviderCommitmentsLogger>();
            _logger.Setup(x => x.Info(It.IsAny <string>(), It.IsAny <long?>(), It.IsAny <long?>(), It.IsAny <long?>())).Verifiable();
            _logger.Setup(x => x.Error(It.IsAny <Exception>(), It.IsAny <string>(), It.IsAny <long?>(), It.IsAny <long?>(), It.IsAny <long?>())).Verifiable();

            var uploadFileParser = new BulkUploadFileParser(_logger.Object);
            var bulkUploader     = new BulkUploader(_mockMediator.Object, uploadValidator, uploadFileParser, Mock.Of <IProviderCommitmentsLogger>());
            var bulkUploadMapper = new BulkUploadMapper(_mockMediator.Object);

            _sut = new BulkUploadOrchestrator(_mockMediator.Object, bulkUploader, mockHashingService.Object,
                                              bulkUploadMapper, Mock.Of <IProviderCommitmentsLogger>(), Mock.Of <IBulkUploadFileParser>(), _mockReservationsService.Object);
        }
 public BulkUploadController(BulkUploadOrchestrator bulkUploadOrchestrator, ICookieStorageService <FlashMessageViewModel> flashMessage) : base(flashMessage)
 {
     _bulkUploadOrchestrator = bulkUploadOrchestrator;
 }