public CoreBackgroundJobPerformerFacts()
 {
     _activator = new Mock <JobActivator>()
     {
         CallBase = true
     };
     _context = new PerformContextMock();
 }
        public BackgroundJobPerformerFacts()
        {
            _context        = new PerformContextMock();
            _innerPerformer = new Mock <IBackgroundJobPerformer>();

            _filters        = new List <object>();
            _filterProvider = new Mock <IJobFilterProvider>();
            _filterProvider.Setup(x => x.GetFilters(It.IsNotNull <Job>())).Returns(
                _filters.Select(f => new JobFilter(f, JobFilterScope.Type, null)));
        }
        public CoreBackgroundJobPerformerFacts()
        {
            _activator = new Mock <JobActivator>()
            {
                CallBase = true
            };
            _context = new PerformContextMock();

            _filters        = new List <object>();
            _filterProvider = new Mock <IJobFilterProvider>();
            _filterProvider.Setup(x => x.GetFilters(It.IsNotNull <Job>())).Returns(
                _filters.Select(f => new JobFilter(f, JobFilterScope.Type, null)));
        }
        public void ResumptionAttribute_LogResumption_Connect_True()
        {
            var          workflowId      = Guid.NewGuid().ToString();
            const string environment     = "";
            const string versionNumber   = "0";
            var          startActivityId = Guid.NewGuid().ToString();

            var values = new Dictionary <string, StringBuilder>
            {
                { "resourceID", new StringBuilder(workflowId) },
                { "environment", new StringBuilder(environment) },
                { "startActivityId", new StringBuilder(versionNumber) },
                { "versionNumber", new StringBuilder(startActivityId) }
            };

            var jobId          = Guid.NewGuid().ToString();
            var performContext = new PerformContextMock(jobId, values);

            var mockLogger = new Mock <IExecutionLogPublisher>();

            mockLogger.Setup(o => o.LogResumedExecution(It.IsAny <Audit>())).Verifiable();

            var executeMessage = new ExecuteMessage
            {
                Message  = new StringBuilder("Execution Completed."),
                HasError = false
            };

            var mockResumption = new Mock <IResumption>();

            mockResumption.Setup(o => o.Connect()).Returns(true);
            mockResumption.Setup(o => o.Resume(values)).Returns(executeMessage);

            var mockResumptionFactory = new Mock <IResumptionFactory>();

            mockResumptionFactory.Setup(o => o.New()).Returns(mockResumption.Object).Verifiable();

            var resumptionAttribute = new ResumptionAttribute(mockLogger.Object, mockResumptionFactory.Object);

            resumptionAttribute.OnPerformResume(new PerformingContext(performContext.Object));

            mockResumptionFactory.Verify(o => o.New(), Times.Once);
            mockResumption.Verify(o => o.Connect(), Times.Once);
            mockLogger.Verify(o => o.LogResumedExecution(It.IsAny <Audit>()), Times.Once);
            mockResumption.Verify(o => o.Resume(values), Times.Once);
        }
 public CoreBackgroundJobPerformerFacts()
 {
     _activator = new Mock<JobActivator>() { CallBase = true };
     _context = new PerformContextMock();
 }