public void HasTriggerWithJobId_QueryByMatchingJobId_ReturnsListWithSingle()
{
// Arrange
var instantTrigger = new InstantTrigger {
IsActive = true
};
var recurringTrigger = new RecurringTrigger()
{
IsActive = true
};
var scheduledTrigger = new ScheduledTrigger {
IsActive = true
};
this.Services.JobStorageProvider.AddTrigger(100, instantTrigger);
this.Services.JobStorageProvider.AddTrigger(200, recurringTrigger);
this.Services.JobStorageProvider.AddTrigger(300, scheduledTrigger);
// Act
var triggers = this.QueryService.GetTriggersByJobId(200, 1, 50).Items;
var assertingRecurringTrigger = triggers[0] as ComponentModel.Management.Model.RecurringTrigger;
// Test
Assert.IsNotNull(triggers);
Assert.AreEqual(1, triggers.Count);
Assert.AreEqual(recurringTrigger.Id, assertingRecurringTrigger.Id);
}
public void JobRunIsScheduler_WhenTriggerGetsDisabled_JobRunWillBeRemoved()
{
var jobManagementService = this.Services.JobManagementService;
var storageProvider = this.Services.JobStorageProvider;
var demoJob = new Job();
storageProvider.AddJob(demoJob);
var futureDate1 = DateTime.UtcNow.AddHours(2);
var trigger = new ScheduledTrigger {
JobId = demoJob.Id, StartDateTimeUtc = futureDate1, IsActive = true
};
jobManagementService.AddTrigger(demoJob.Id, trigger);
// Wait for the scheduler to do his work
WaitFor.HasElements(() => storageProvider.GetJobRuns().Items);
var createdJobRun = storageProvider.GetJobRuns().Items.FirstOrDefault();
Assert.IsNotNull(createdJobRun, "There should be exact one JobRun");
Assert.IsTrue(createdJobRun.PlannedStartDateTimeUtc >= DateTime.UtcNow, "The job run needs to be in the future");
Assert.AreEqual(futureDate1, createdJobRun.PlannedStartDateTimeUtc);
jobManagementService.DisableTrigger(demoJob.Id, trigger.Id);
// Wait for the scheduler to do his work
WaitFor.HasElements(() => storageProvider.GetJobRuns().Items.Where(r => r.State == ComponentModel.JobStorage.Model.JobRunStates.Deleted).ToList());
var jobRun = storageProvider.GetJobRuns().Items.FirstOrDefault();
Assert.AreEqual(ComponentModel.JobStorage.Model.JobRunStates.Deleted, jobRun.State);
}
public void HasOneJobRun_QueryByExistingTriggerId_ReturnsListWithSingle()
{
// Arrange
var job = new Job {
Id = 1337
};
var trigger = new ScheduledTrigger {
Id = 34
};
var jobRun = new JobRun {
Job = job, Trigger = trigger
};
this.Services.JobStorageProvider.AddJobRun(jobRun);
// Act
var runs = this.QueryService.GetJobRunsByTriggerId(1337, 34);
Assert.IsNotNull(runs);
Assert.AreEqual(1, runs.Items.Count);
Assert.AreEqual(jobRun.Id, runs.Items[0].Id);
Assert.AreEqual(34, runs.Items[0].TriggerId);
Assert.AreEqual(1337, runs.Items[0].JobId);
}
public void JobRunIsScheduler_WhenTriggerIsEnabled_JobRunWillBeScheduled()
{
var jobManagementService = this.Services.JobManagementService;
var storageProvider = this.Services.JobStorageProvider;
var demoJob = new Job();
storageProvider.AddJob(demoJob);
var futureDate1 = DateTime.UtcNow.AddHours(2);
var trigger = new ScheduledTrigger {
JobId = demoJob.Id, StartDateTimeUtc = futureDate1, IsActive = false
};
jobManagementService.AddTrigger(demoJob.Id, trigger);
// Base asserts
var createdJobRun = storageProvider.GetJobRuns().Items.FirstOrDefault();
Assert.IsNull(createdJobRun, "There should be exact no JobRun");
jobManagementService.EnableTrigger(demoJob.Id, trigger.Id);
// Wait for the scheduler to do his work
WaitFor.HasElements(() => storageProvider.GetJobRuns().Items);
var jobRun = storageProvider.GetJobRuns().Items.FirstOrDefault();
Assert.AreEqual(JobRunStates.Scheduled, jobRun.State);
}
public void JobService_ExistingScheduledTriggerIsUpdated_UpdateIsPersisted()
{
var demoJob = new Job();
var storageProvider = this.Services.JobStorageProvider;
storageProvider.AddJob(demoJob);
var futureDate1 = DateTime.UtcNow.AddHours(2);
var futureDate2 = DateTime.UtcNow.AddHours(5);
var initialTrigger = new ScheduledTrigger {
JobId = demoJob.Id, StartDateTimeUtc = futureDate1, IsActive = true
};
storageProvider.AddTrigger(demoJob.Id, initialTrigger);
var updatedTrigger = new ScheduledTrigger {
Id = initialTrigger.Id, JobId = demoJob.Id, StartDateTimeUtc = futureDate2, IsActive = true
};
this.Services.JobManagementService.UpdateTriggerStartTime(demoJob.Id, updatedTrigger.Id, updatedTrigger.StartDateTimeUtc);
var assertTrigger = (ScheduledTrigger)storageProvider.GetTriggerById(demoJob.Id, initialTrigger.Id);
Assert.AreEqual(futureDate2, assertTrigger.StartDateTimeUtc);
}
internal static ScheduledTrigger ConvertToTrigger(ScheduledTriggerDto dto)
{
var trigger = new ScheduledTrigger {
StartDateTimeUtc = dto.StartDateTimeUtc
};
return((ScheduledTrigger)MapCommonValues(dto, trigger));
}
internal static ScheduledTriggerDto ConvertToDto(ScheduledTrigger trigger)
{
var dto = new ScheduledTriggerDto {
StartDateTimeUtc = trigger.StartDateTimeUtc
};
return((ScheduledTriggerDto)MapCommonValues(trigger, dto));
}
public void AddTrigger(long jobId, ScheduledTrigger trigger)
{
var newTriggerId = this.localTriggers.Count + 1;
trigger.Id = newTriggerId;
trigger.JobId = jobId;
this.localTriggers.Add(trigger);
}
public void Update(long jobId, ScheduledTrigger trigger)
{
using (var connection = this.connectionFactory.Open())
{
var entity = trigger.ToEntity();
connection.Update(entity);
}
}
public void AddTrigger(long jobId, ScheduledTrigger trigger)
{
var model = this.mapper.Map <ScheduledTriggerModel>(trigger);
this.triggerService.Add(jobId, model);
trigger.Id = model.Id;
trigger.JobId = jobId;
}
public void NewScheduledTrigger_IsAdded_WillBePlanned()
{
var scheduledTrigger = new ScheduledTrigger {
JobId = this.demoJob1Id, StartDateTimeUtc = DateTime.UtcNow.AddSeconds(-1), IsActive = true
};
this.AddAndSignalNewTrigger(this.demoJob1Id, scheduledTrigger);
Assert.AreEqual(1, this.lastIssuedPlan.Count, "A scheduled trigger should cause one item in the plan");
}
private bool ApplyOtherChanges(ScheduledTrigger fromDb, ScheduledTrigger updatedOne)
{
if (fromDb.StartDateTimeUtc != updatedOne.StartDateTimeUtc)
{
fromDb.StartDateTimeUtc = updatedOne.StartDateTimeUtc;
return(true);
}
return(false);
}
public void NewScheduledTrigger_IsAdded_CreatesANewJobRun()
{
var scheduledTrigger = new ScheduledTrigger {
JobId = this.demoJob1Id, StartDateTimeUtc = DateTime.UtcNow.AddSeconds(-1), IsActive = true
};
this.AddAndSignalNewTrigger(this.demoJob1Id, scheduledTrigger);
var jobRuns = this.repository.GetJobRuns();
Assert.AreEqual(1, jobRuns.Count, "A scheduled trigger should create exact one jobrun when added");
Assert.AreEqual(scheduledTrigger.Id, jobRuns.Single().TriggerId, "The jobrun should reference the trigger that cause the job to run");
}
private void InsertTrigger(ScheduledTrigger trigger)
{
var entity = trigger.ToEntity();
if (entity.CreatedDateTimeUtc == default(DateTime))
{
entity.CreatedDateTimeUtc = DateTime.UtcNow;
}
using (var connection = this.connectionFactory.OpenDbConnection())
{
trigger.Id = connection.Insert(entity, true);
}
}
public static ComponentModel.JobStorage.Model.ScheduledTrigger ToModel(this ScheduledTrigger src, long jobId)
{
return(new ComponentModel.JobStorage.Model.ScheduledTrigger
{
Id = src.Id,
CreatedDateTimeUtc = src.CreatedDateTimeUtc,
Parameters = src.Parameters,
StartDateTimeUtc = src.StartDateTimeUtc,
IsActive = src.IsActive,
UserId = src.UserId,
Comment = src.Comment,
UserDisplayName = src.UserDisplayName,
JobId = jobId
});
}
public void NewScheduledTrigger_IsAdded_IsPlannedOnTime()
{
var dateTimeUtc = DateTime.UtcNow.AddHours(10);
var scheduledTrigger = new ScheduledTrigger {
JobId = this.demoJob1Id, StartDateTimeUtc = dateTimeUtc, IsActive = true
};
this.AddAndSignalNewTrigger(this.demoJob1Id, scheduledTrigger);
var jobRun = this.repository.GetJobRuns().Single();
Assert.AreEqual(dateTimeUtc, this.lastIssuedPlan.Single().PlannedStartDateTimeUtc, "The startdate should be considered in the plan");
Assert.AreEqual(jobRun.Id, this.lastIssuedPlan.Single().Id, "The startdate should be considered in the plan");
}
public void Update(long jobId, ScheduledTrigger trigger)
{
using (var session = this._documentStore.OpenSession())
{
var job = session.Load <Model.Job>(jobId);
var triggerFromDb = job.ScheduledTriggers.First(p => p.Id == trigger.Id);
job.ScheduledTriggers.Remove(triggerFromDb);
var entity = trigger.ToEntity();
job.ScheduledTriggers.Add(entity);
session.Store(job);
session.SaveChanges();
}
}
public void AddTrigger(long jobId, ScheduledTrigger trigger)
{
using (var session = this._documentStore.OpenSession())
{
var job = session.Load <Model.Job>(jobId);
var entity = trigger.ToEntity();
entity.Id = ++job.LastTriggerId;
entity.CreatedDateTimeUtc = DateTime.UtcNow;
job.ScheduledTriggers.Add(entity);
session.Store(job);
session.SaveChanges();
trigger.Id = entity.Id;
trigger.CreatedDateTimeUtc = entity.CreatedDateTimeUtc;
}
}
private bool ApplyOtherChanges(ScheduledTrigger fromDb, ScheduledTrigger updatedOne)
{
bool hadChanges = false;
if (fromDb.StartDateTimeUtc != updatedOne.StartDateTimeUtc)
{
fromDb.StartDateTimeUtc = updatedOne.StartDateTimeUtc;
hadChanges = true;
}
if (this.ApplyBaseChanges(fromDb, updatedOne))
{
hadChanges = true;
}
return(hadChanges);
}
public void GetScheduledTrigger()
{
using (this.GivenRunningServerWithWebApi())
{
var client = new JobbrClient(this.BackendAddress);
var job = new Job();
this.JobStorage.AddJob(job);
var trigger = new ScheduledTrigger();
this.JobStorage.AddTrigger(job.Id, trigger);
var triggerDto = client.GetTriggerById <ScheduledTriggerDto>(job.Id, trigger.Id);
Assert.IsNotNull(triggerDto);
Assert.AreEqual(trigger.Id, triggerDto.Id);
}
}
public static Entities.Trigger ToEntity(this ScheduledTrigger model)
{
return(new Entities.Trigger
{
Id = model.Id,
UserId = model.UserId,
UserDisplayName = model.UserDisplayName,
JobId = model.JobId,
IsActive = model.IsActive,
Comment = model.Comment,
Parameters = model.Parameters,
CreatedDateTimeUtc = model.CreatedDateTimeUtc,
Type = Entities.TriggerType.ScheduledTrigger,
NoParallelExecution = false,
StartDateTimeUtc = model.StartDateTimeUtc,
Deleted = model.Deleted,
});
}
internal PlanResult Plan(ScheduledTrigger trigger, bool isNew)
{
if (!trigger.IsActive)
{
return(PlanResult.FromAction(PlanAction.Obsolete));
}
var calculatedNextRun = trigger.StartDateTimeUtc;
if (calculatedNextRun < this.dateTimeProvider.GetUtcNow() && !isNew)
{
return(PlanResult.FromAction(PlanAction.Obsolete));
}
return(new PlanResult {
Action = PlanAction.Possible, ExpectedStartDateUtc = calculatedNextRun
});
}
public void ScheduledTrigger_HasCompletedJobRun_DoesNotTriggerNewOne()
{
// Note: The Scheduled Trigger needs to be in the past in order to invalidate the job reliable in this testing scenario (Issues with NCrunch, no issues with R# and VS-Runners)
var scheduledTrigger = new ScheduledTrigger {
JobId = this.demoJob1Id, StartDateTimeUtc = DateTime.UtcNow.AddSeconds(-1), IsActive = true
};
this.AddAndSignalNewTrigger(this.demoJob1Id, scheduledTrigger);
// Simulate Job Completeness
var jobRunByScheduledTrigger = this.repository.GetJobRuns().Single(jr => jr.TriggerId == scheduledTrigger.Id);
jobRunByScheduledTrigger.State = JobRunStates.Completed;
this.repository.Update(jobRunByScheduledTrigger);
this.scheduler.OnJobRunEnded(jobRunByScheduledTrigger.Id);
Assert.AreEqual(0, this.lastIssuedPlan.Count, "A scheduled trigger should not cause any additional jobruns after completion");
}
public void UpdateScheduledTrigger()
{
using (this.GivenRunningServerWithWebApi())
{
var client = new JobbrClient(this.BackendAddress);
var job = new Job();
this.JobStorage.AddJob(job);
var trigger = new ScheduledTrigger();
this.JobStorage.AddTrigger(job.Id, trigger);
var triggerDto = client.UpdateTrigger(job.Id, new ScheduledTriggerDto {
Id = trigger.Id, IsActive = true
});
Assert.IsNotNull(triggerDto);
Assert.IsTrue(triggerDto.IsActive);
}
}
public static PSDataShareTrigger ToPsObject(this ScheduledTrigger trigger)
{
var parsedResourceId = new ResourceIdentifier(trigger.Id);
return(new PSDataShareTrigger
{
Id = trigger.Id,
Name = trigger.Name,
Type = trigger.Type,
ProvisioningState = (PSProvisioningState)Enum.Parse(
typeof(PSProvisioningState),
trigger.ProvisioningState),
CreatedAt = trigger.CreatedAt,
CreatedBy = trigger.UserName,
RecurrenceInterval = trigger.RecurrenceInterval,
SynchronizationMode = trigger.SynchronizationMode,
SynchronizationTime = trigger.SynchronizationTime,
TriggerStatus = trigger.TriggerStatus,
});
}
public void HasOneJobRun_QueryByInExistentTriggerId_ReturnsEmptyList()
{
// Arrange
var job = new Job {
Id = 1000
};
var trigger = new ScheduledTrigger {
Id = 34
};
this.Services.JobStorageProvider.AddJobRun(new JobRun {
Job = job, Trigger = trigger
});
// Act
var runs = this.QueryService.GetJobRunsByTriggerId(-1, -1);
Assert.IsNotNull(runs);
Assert.AreEqual(0, runs.Items.Count);
}
private void CreateNewTrigger()
{
var triggerModel = new ScheduledTrigger
{
RecurrenceInterval = this.RecurrenceInterval,
SynchronizationTime = this.SynchronizationTime,
SynchronizationMode = SynchronizationMode.Incremental
};
var createFunc =
(Func <string, string, string, string, Trigger, Trigger>) this.DataShareManagementClient.Triggers.Create;
var trigger = createFunc(
this.ResourceGroupName,
this.AccountName,
this.ShareSubscriptionName,
this.Name,
triggerModel) as ScheduledTrigger;
this.WriteObject(trigger.ToPsObject());
}
public void HasDifferentTriggerTypes_QueryById_ReturnsCorrectType()
{
// Arrange
const long jobId = 1;
var instantTrigger = new InstantTrigger();
var recurringTrigger = new RecurringTrigger();
var scheduledTrigger = new ScheduledTrigger();
this.Services.JobStorageProvider.AddTrigger(jobId, instantTrigger);
this.Services.JobStorageProvider.AddTrigger(jobId, recurringTrigger);
this.Services.JobStorageProvider.AddTrigger(jobId, scheduledTrigger);
// Act
var instantTypeTrigger = this.QueryService.GetTriggerById(jobId, instantTrigger.Id);
var recurringTypeTrigger = this.QueryService.GetTriggerById(jobId, recurringTrigger.Id);
var scheduledTypeTrigger = this.QueryService.GetTriggerById(jobId, scheduledTrigger.Id);
// Test
Assert.AreEqual(typeof(ComponentModel.Management.Model.InstantTrigger), instantTypeTrigger.GetType());
Assert.AreEqual(typeof(ComponentModel.Management.Model.RecurringTrigger), recurringTypeTrigger.GetType());
Assert.AreEqual(typeof(ComponentModel.Management.Model.ScheduledTrigger), scheduledTypeTrigger.GetType());
}
public void JobRunIsScheduled_ScheduledTriggerGetsUpdated_JobRunScheduleIsAdjusted()
{
var jobManagementService = this.Services.JobManagementService;
var storageProvider = this.Services.JobStorageProvider;
var demoJob = new Job();
storageProvider.AddJob(demoJob);
var futureDate1 = DateTime.UtcNow.AddHours(1);
var futureDate2 = DateTime.UtcNow.AddHours(10);
var recurringTrigger = new ScheduledTrigger()
{
JobId = 1, StartDateTimeUtc = futureDate1, IsActive = true
};
jobManagementService.AddTrigger(1, recurringTrigger);
// Wait for the scheduler to do his work
WaitFor.HasElements(() => storageProvider.GetJobRuns().Items);
var createdJobRun = storageProvider.GetJobRuns().Items.FirstOrDefault();
// Base Assertions
Assert.IsNotNull(createdJobRun, "There should be exact one JobRun which is not null");
Assert.IsTrue(createdJobRun.PlannedStartDateTimeUtc >= DateTime.UtcNow, "The job run needs to be in the future");
Assert.AreEqual(futureDate1, createdJobRun.PlannedStartDateTimeUtc);
jobManagementService.UpdateTriggerStartTime(1, recurringTrigger.Id, futureDate2);
// Wait for the scheduler to do his work
WaitFor.HasElements(() => storageProvider.GetJobRuns().Items.Where(r => r.PlannedStartDateTimeUtc == futureDate2).ToList());
var updatedJobRun = storageProvider.GetJobRuns().Items.FirstOrDefault();
Assert.AreEqual(futureDate2, updatedJobRun.PlannedStartDateTimeUtc, "As per updated startddate, the job should now start on a different point in time");
}
public void GivenScheduledTrigger_WhenUpdating_TriggerIsUpdated()
{
GivenRavenDb();
GivenStorageProvider();
var job1 = new Job {
UniqueName = "testjob1", Type = "Jobs.Test1"
};
this.StorageProvider.AddJob(job1);
var trigger = new ScheduledTrigger {
StartDateTimeUtc = DateTime.UtcNow
};
this.StorageProvider.AddTrigger(job1.Id, trigger);
var trigger2 = (ScheduledTrigger)this.StorageProvider.GetTriggerById(job1.Id, trigger.Id);
var startDateTime = DateTime.UtcNow.AddHours(5);
trigger2.Comment = "bla";
trigger2.IsActive = true;
trigger2.Parameters = "test-parameters";
trigger2.UserId = "ozu";
trigger2.StartDateTimeUtc = startDateTime;
this.StorageProvider.Update(job1.Id, trigger2);
var trigger2Reloaded = (ScheduledTrigger)this.StorageProvider.GetTriggerById(job1.Id, trigger2.Id);
Assert.AreEqual("bla", trigger2Reloaded.Comment);
Assert.IsTrue(trigger2Reloaded.IsActive);
Assert.AreEqual("test-parameters", trigger2Reloaded.Parameters);
Assert.AreEqual("ozu", trigger2Reloaded.UserId);
Assert.AreEqual(startDateTime.ToString(CultureInfo.InvariantCulture), trigger2Reloaded.StartDateTimeUtc.ToString(CultureInfo.InvariantCulture));
}
