public ImportCampaignMembersHandler(IChunkingService chunkingService, ICsvService csvService, IBulkImportService bulkImportService, ILogger <ImportCampaignMembersHandler> logger)
 {
     _chunkingService   = chunkingService;
     _csvService        = csvService;
     _bulkImportService = bulkImportService;
     _logger            = logger;
 }
Пример #2
0
 public MarketoBulkImportService(IMarketoLeadClient marketoLeadClient,
                                 IMarketoBulkImportClient marketoBulkImportClient, ICsvService csvService, ILogger <MarketoBulkImportService> logger, IBulkImportStatusMapper bulkImportStatusMapper, IBulkImportJobMapper bulkImportJobMapper, IChunkingService chunkingService, IOptions <MarketoConfiguration> marketoOptions)
 {
     _marketoLeadClient       = marketoLeadClient;
     _marketoBulkImportClient = marketoBulkImportClient;
     _csvService             = csvService;
     _logger                 = logger;
     _bulkImportStatusMapper = bulkImportStatusMapper;
     _bulkImportJobMapper    = bulkImportJobMapper;
     _chunkingService        = chunkingService;
     _marketoOptions         = marketoOptions;
 }
        public void Arrange()
        {
            _bulkImportServiceMock = new Mock <IBulkImportService>();
            _logger = new Mock <ILogger <ImportEmployerUsersHandler> >();
            _employerUsersRepositoryMock = new Mock <IEmployerUsersRepository>();
            _PersonMapperMock            = new Mock <IPersonMapper>();

            _bulkImportServiceMock.Setup(s => s.ImportPeople(It.IsAny <IList <dynamic> >())).ReturnsAsync(new BulkImportStatus());
            _employerUsersRepositoryMock.Setup(s => s.GetAllUsers()).ReturnsAsync(_testUserList);
            _PersonMapperMock.Setup(s => s.Map(It.IsAny <EmployerUser>())).Returns(new Person());

            var marketoConfig = new Mock <IOptions <MarketoConfiguration> >();

            marketoConfig.Setup(x => x.Value.ChunkSizeKB).Returns(10000);    // 10MB chunk size
            _chunkingService = new ChunkingService(marketoConfig.Object);

            _handler = new ImportEmployerUsersHandler(_bulkImportServiceMock.Object, _logger.Object, _employerUsersRepositoryMock.Object, _PersonMapperMock.Object);
        }
        public void Arrange()
        {
            _marketoLeadClientMock       = new Mock <IMarketoLeadClient>();
            _marketoBulkImportClientMock = new Mock <IMarketoBulkImportClient>();
            _bulkImportJobMapperMock     = new Mock <IBulkImportJobMapper>();
            _bulkImportStatusMapperMock  = new Mock <IBulkImportStatusMapper>();
            _chunkingServiceMock         = new Mock <IChunkingService>();
            _csvServiceMock = new Mock <ICsvService>();
            _logger         = new Mock <ILogger <MarketoBulkImportService> >();
            var marketoConfig = new Mock <IOptions <MarketoConfiguration> >();

            var jobResponse = new Response <BatchJob>()
            {
                RequestId = "RequestId",
                Success   = true,
                Result    = new List <BatchJob>()
            };

            marketoConfig.Setup(x => x.Value.ApiRetryCount).Returns(1);
            marketoConfig.Setup(x => x.Value.ApiRetryInitialBackOffSecs).Returns(1);
            marketoConfig.Setup(x => x.Value.ChunkSizeKB).Returns(10000);    // 10MB chunk size

            _chunkingService = new ChunkingService(marketoConfig.Object);

            _chunkingServiceMock.Setup(s => s.GetChunks(172, _testLeadList))
            .Returns(_chunkingService.GetChunks(172, _testLeadList));
            _csvServiceMock.Setup(s => s.GetByteCount(_testLeadList)).Returns(172);
            _marketoBulkImportClientMock.Setup(s => s.PushLeads(It.IsAny <StreamPart>())).ReturnsAsync(jobResponse);

            _marketoLeadClientMock.Setup(s => s.Describe()).ReturnsAsync(GenerateDescribeReturn());


            _service = new MarketoBulkImportService(_marketoLeadClientMock.Object,
                                                    _marketoBulkImportClientMock.Object,
                                                    _csvServiceMock.Object,
                                                    _logger.Object,
                                                    _bulkImportStatusMapperMock.Object,
                                                    _bulkImportJobMapperMock.Object,
                                                    _chunkingServiceMock.Object,
                                                    marketoConfig.Object);
        }
Пример #5
0
        public void Arrange()
        {
            _chunkingServiceMock = new Mock <IChunkingService>();
            _csvService          = new Mock <ICsvService>();
            _bulkImportService   = new Mock <IBulkImportService>();
            _logger        = new Mock <ILogger <ImportCampaignMembersHandler> >();
            _reportService = new Mock <IReportService>();
            var marketoConfig = new Mock <IOptions <MarketoConfiguration> >();

            marketoConfig.Setup(x => x.Value.ChunkSizeKB).Returns(10000);    // 10MB chunk size

            _chunkingService = new ChunkingService(marketoConfig.Object);
            _csvService.Setup(s => s.ConvertToList(It.IsAny <StreamReader>())).ReturnsAsync(_testLeadList);
            _chunkingServiceMock.Setup(s => s.GetChunks(It.IsAny <int>(), _testLeadList))
            .Returns(new List <IList <dynamic> >());
            _bulkImportService.Setup(s => s.ImportPeople(It.IsAny <IList <dynamic> >())).ReturnsAsync(new BulkImportStatus());
            _bulkImportService.Setup(s => s.ValidateFields(It.IsAny <IList <string> >()))
            .ReturnsAsync(new FieldValidationResult());

            _handler = new ImportCampaignMembersHandler(_chunkingServiceMock.Object, _csvService.Object, _bulkImportService.Object, _logger.Object);
        }