public void AndTest()
{
TriggerStub triggerA = new TriggerStub("A");
TriggerStub triggerB = new TriggerStub("B");
TriggerInput combined = triggerA.And(triggerB);
Assert.That(combined.ToString(), Is.EqualTo("A+B"));
ValueSpy <bool> spy = new ValueSpy <bool>(combined);
triggerA.Update(true);
spy.WaitFrame();
spy.AssertNothingHappened();
triggerA.Update(false);
triggerB.Update(true);
spy.WaitFrame();
spy.AssertNothingHappened();
triggerA.Update(true);
spy.WaitFrame();
spy.AssertWasUpdatedTo(true);
triggerA.Update(false);
spy.WaitFrame();
spy.AssertWasUpdatedTo(false);
triggerB.Update(false);
spy.WaitFrame();
spy.AssertNothingHappened();
}
public void StopCleansUpTriggers()
{
var cleaned = false;
var trigger = new TriggerStub
{
OnCleanUp = () => cleaned = true,
OnCheckAction = () => null
};
var project = new ProjectStub("Test")
{
OnLoadState = () => { }
};
project.Triggers.Add(trigger);
project.Start();
// Give the project time to start
Thread.Sleep(100);
project.Stop();
// Give the project time to stop
Thread.Sleep(1000);
Assert.IsTrue(cleaned);
Assert.IsNull(project.MainThreadException);
}
public void TriggerFiresIfOutsidePeriod()
{
var clockMock = new Mock <IClock>();
var time = DateTime.Now;
clockMock.Setup(c => c.Now).Returns(() =>
{
time = time.AddMinutes(10);
return(time);
});
var inner = new TriggerStub
{
OnCheckAction = () => new IntegrationRequest("Test")
};
var trigger = new RollUp(TimeSpan.FromMinutes(5))
{
InnerTrigger = inner,
Clock = clockMock.Object
};
trigger.Reset();
var request = trigger.Check();
Assert.IsNotNull(request);
}
public void Execute_JobClassProvided_ShouldScheduleNewJob()
{
const string groupName = "Group";
const string jobName = "Job";
var stub = new SchedulerHostStub(new[] { typeof(System.Object) });
var command = new AddTriggerCommand(() => stub.Value, new RegisteredInputType[0]);
AddTriggerOutput result = (AddTriggerOutput)command.Execute(new AddTriggerInput
{
Group = groupName,
Job = jobName,
JobClass = typeof(System.Object).ToString(),
Name = "Trigger",
TriggerType = "Simple"
});
result.AssertSuccessfull();
GroupStub group = stub.GetSingleGroup();
JobStub job = group.GetSingleJob();
TriggerStub trigger = job.GetSingleTrigger();
Assert.That(group.Name, Is.EqualTo(groupName));
Assert.That(job.Name, Is.EqualTo(jobName));
Assert.That(job.JobType, Is.EqualTo(typeof(System.Object)));
Assert.That(trigger.Name, Is.EqualTo("Trigger"));
}
public void JobWasExecuted_ListenToJobs_ShouldEmitEvent()
{
const string fireInstanceId = "fire-42";
const string triggerKey = "fire-42";
var emitted = ExecuteAndGetEvent(
new Quartz3SchedulerEventSource(true),
eventSource =>
{
var trigger = new TriggerStub(triggerKey);
eventSource.JobWasExecuted(
new JobExecutionContextStub
{
Trigger = trigger,
FireInstanceId = fireInstanceId
},
null);
});
Assert.That(emitted, Is.Not.Null);
Assert.That(emitted.Error, Is.Null);
Assert.That(emitted.EventType, Is.EqualTo(SchedulerEventType.Complete));
Assert.That(emitted.FireInstanceId, Is.EqualTo(fireInstanceId));
Assert.That(emitted.ItemKey, Is.EqualTo("DEFAULT." + triggerKey));
Assert.That(emitted.Scope, Is.EqualTo(SchedulerEventScope.Trigger));
}
public void TestInputTrigger()
{
// Prepare datas
Trigger input_Trigger = new TriggerStub();
State state_stub = new StateStub();
State expected_CurrentState = state_stub;
FieldInfo current_state_field_info = StateMachineInstance.GetType().GetField("CurrentState",
BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance);
State before_CurrentState = (State)current_state_field_info.GetValue(StateMachineInstance);
// Prepare mocks
var transition_mock = new TransitionExecuteReturnParticularStateMock(state_stub);
transition_mock.HasCalledExecute = false;
var transition_matrix_mock = new TransitionMatrixSearchTransitionReturnParticularTransitionMock(transition_mock);
transition_matrix_mock.HasCalledSearchTransition = false;
FieldInfo transition_matrix_data_field_info = StateMachineInstance.GetType().GetField("TransitionMatrixData",
BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Instance);
transition_matrix_data_field_info.SetValue(StateMachineInstance, transition_matrix_mock);
// Execute
StateMachineInstance.InputTrigger(input_Trigger);
// Get results
State actual_CurrentState = (State)current_state_field_info.GetValue(StateMachineInstance);
// Validate
Assert.True(transition_matrix_mock.HasCalledSearchTransition);
Assert.True(transition_mock.HasCalledExecute);
Assert.NotSame(before_CurrentState, actual_CurrentState);
Assert.Same(expected_CurrentState, actual_CurrentState);
}
public void TriggerComplete_ListenToTriggers_ShouldEmitEvent()
{
const string fireInstanceId = "fire-42";
const string triggerKey = "fire-42";
var emitted = ExecuteAndGetEvent(
new Quartz2SchedulerEventSource(false),
eventSource =>
{
var trigger = new TriggerStub(triggerKey);
eventSource.TriggerComplete(
trigger,
new JobExecutionContextStub
{
FireInstanceId = fireInstanceId,
Trigger = trigger
},
SchedulerInstruction.SetTriggerComplete);
});
Assert.That(emitted, Is.Not.Null);
Assert.That(emitted.Error, Is.Null);
Assert.That(emitted.EventType, Is.EqualTo(SchedulerEventType.Complete));
Assert.That(emitted.FireInstanceId, Is.EqualTo(fireInstanceId));
Assert.That(emitted.ItemKey, Is.EqualTo("DEFAULT." + triggerKey));
Assert.That(emitted.Scope, Is.EqualTo(SchedulerEventScope.Trigger));
}
public void Execute_NoJobClass_ShouldAddTriggerToExistingJob()
{
const string groupName = "Group";
const string jobName = "Job";
var stub = new SchedulerHostStub();
var command = new AddTriggerCommand(() => stub.Value, new RegisteredInputType[0]);
AddTriggerOutput result = (AddTriggerOutput)command.Execute(new AddTriggerInput
{
Group = groupName,
Job = jobName,
Name = "Trigger",
TriggerType = "Simple"
});
result.AssertSuccessfull();
GroupStub group = stub.GetSingleGroup();
JobStub job = group.GetSingleJob();
TriggerStub trigger = job.GetSingleTrigger();
Assert.That(group.Name, Is.EqualTo(groupName));
Assert.That(job.Name, Is.EqualTo(jobName));
Assert.That(job.JobType, Is.Null);
Assert.That(trigger.Name, Is.EqualTo("Trigger"));
}
public async Task CreateWeakDelegate_WrapsTargetMethod()
{
var triggerStub = new TriggerStub <object>();
var triggerContextStub = new TriggerContextStub <object>();
var weakDelegate = TriggerTypeDescriptorHelpers.GetWeakDelegate(typeof(IBeforeSaveTrigger <object>), typeof(object), typeof(IBeforeSaveTrigger <object>).GetMethod("BeforeSave"));
await weakDelegate(triggerStub, triggerContextStub, default);
Assert.NotEmpty(triggerStub.BeforeSaveInvocations);
}
public async Task Execute_ForwardsCall()
{
var entityType = typeof(string);
var triggerStub = new TriggerStub <string>();
var subject = new BeforeRollbackTriggerDescriptor(entityType);
await subject.Invoke(triggerStub, new TriggerContextStub <string>(), null, default);
Assert.Single(triggerStub.BeforeRollbackInvocations);
}
public void SettingProjectSetsChildrenProjects()
{
var project = new Core.Project();
var child = new TriggerStub();
new Multiple(child)
{
Project = project
};
Assert.AreSame(project, child.Project);
}
public async Task Execute_ForwardsCall()
{
var entityType = typeof(string);
var exception = new Exception();
var triggerStub = new TriggerStub <string>();
var subject = new AfterSaveFailedTriggerDescriptor(entityType, exception);
await subject.Invoke(triggerStub, new TriggerContextStub <string>(), exception, default);
Assert.Single(triggerStub.AfterSaveFailedInvocations);
Assert.Equal(exception, triggerStub.AfterSaveFailedInvocations.First().exception);
}
public void ResetResetsChildren()
{
var reset = false;
var child = new TriggerStub
{
OnResetAction = () => reset = true
};
var trigger = new Multiple(child);
trigger.Reset();
Assert.IsTrue(reset);
}
public void CleanUpCleansChildren()
{
var cleaned = false;
var child = new TriggerStub
{
OnCleanUp = () => cleaned = true
};
var trigger = new Multiple(child);
trigger.CleanUp();
Assert.IsTrue(cleaned);
}
public void InitialiseInitialisesChildren()
{
var initialised = false;
var child = new TriggerStub
{
OnInitialise = () => initialised = true
};
var trigger = new Multiple(child);
trigger.Initialise();
Assert.IsTrue(initialised);
}
public void ValidateValidatesChildren()
{
var validated = false;
var child = new TriggerStub
{
OnValidate = vl => validated = true
};
var trigger = new Multiple(child);
var validationMock = new Mock <IValidationLog>();
trigger.Validate(validationMock.Object);
Assert.IsTrue(validated);
}
public void CheckReturnsNullIfAllChildrenNullWithOr()
{
var child1 = new TriggerStub {
OnCheckAction = () => null
};
var child2 = new TriggerStub {
OnCheckAction = () => null
};
var trigger = new Multiple(child1, child2);
var actual = trigger.Check();
Assert.IsNull(actual);
}
public void NextTimeReturnsLowestValidTime()
{
var child1 = new TriggerStub();
var child2 = new TriggerStub {
NextTimeValue = DateTime.Now
};
var child3 = new TriggerStub {
NextTimeValue = DateTime.Now.AddHours(1)
};
var trigger = new Multiple(child1, child2, child3);
var actual = trigger.NextTime;
Assert.AreEqual(child2.NextTimeValue, actual);
}
public void CheckReturnsRequestIfAnyChildSetWithOr()
{
var child1 = new TriggerStub {
OnCheckAction = () => null
};
var child2 = new TriggerStub {
OnCheckAction = () => new IntegrationRequest("Dummy")
};
var trigger = new Multiple(child1, child2);
var actual = trigger.Check();
Assert.IsNotNull(actual);
Assert.AreEqual("Multiple", actual.SourceTrigger);
}
public void ValidateValidatesTriggers()
{
var validateCalled = false;
var trigger = new TriggerStub
{
OnValidate = vl => validateCalled = true
};
var project = new Project("Test");
project.Triggers.Add(trigger);
var validationMock = new Mock <IValidationLog>();
project.Validate(validationMock.Object);
Assert.IsTrue(validateCalled);
}
private AddTriggerOutput AssertTriggerType(AddTriggerInput input, Action <TriggerType> assertAction)
{
var stub = new SchedulerHostStub();
var command = new AddTriggerCommand(() => stub.Value, new RegisteredInputType[0]);
AddTriggerOutput result = (AddTriggerOutput)command.Execute(input);
result.AssertSuccessfull();
TriggerStub trigger = stub.GetSingleGroup().GetSingleJob().GetSingleTrigger();
assertAction(trigger.Trigger);
return(result);
}
public void CheckReturnsNullIfAnyChildNullWithAnd()
{
var child1 = new TriggerStub {
OnCheckAction = () => null
};
var child2 = new TriggerStub {
OnCheckAction = () => new IntegrationRequest("Dummy")
};
var trigger = new Multiple(child1, child2)
{
Condition = CombinationOperator.And
};
var actual = trigger.Check();
Assert.IsNull(actual);
}
public void JobWasExecuted_ListenToTriggers_ShouldNotEmitEvent()
{
var emitted = ExecuteAndGetEvent(
new Quartz2SchedulerEventSource(false),
eventSource =>
{
var trigger = new TriggerStub("any");
eventSource.JobWasExecuted(
new JobExecutionContextStub
{
Trigger = trigger
},
null);
});
Assert.That(emitted, Is.Null);
}
public void CheckReturnsRequestIfAllChildrenSetWithAnd()
{
var child1 = new TriggerStub {
OnCheckAction = () => new IntegrationRequest("Dummy")
};
var child2 = new TriggerStub {
OnCheckAction = () => new IntegrationRequest("Dummy")
};
var trigger = new Multiple(child1, child2)
{
Condition = CombinationOperator.And
};
var actual = trigger.Check();
Assert.IsNotNull(actual);
Assert.AreEqual("Multiple", actual.SourceTrigger);
}
public void TriggerComplete_ListenToJobs_ShouldNotEmitEvent()
{
var emitted = ExecuteAndGetEvent(
new Quartz2SchedulerEventSource(true),
eventSource =>
{
var trigger = new TriggerStub("any");
eventSource.TriggerComplete(
trigger,
new JobExecutionContextStub
{
Trigger = trigger
},
SchedulerInstruction.SetTriggerComplete);
});
Assert.That(emitted, Is.Null);
}
public void TestSearchTransitionFailedSearchTransitionArgumentOutOfRange()
{
// Prepare datas
var transition_matrix_mock = new TransitionMatrixSearchTransitionThrowArgumentOutOfRangeExceptionMock();
transition_matrix_mock.HasCalledSearchTransition = false;
State setting_InitialState = new StateStub();
Trigger input_Trigger = new TriggerStub();
// Prepare mocks
FieldInfo field_info = StateMachineInstance.GetType().GetField("TransitionMatrixData",
BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Instance);
field_info.SetValue(StateMachineInstance, transition_matrix_mock);
// Execute & Validate
Assert.Throws <InvalidOperationException>(() => StateMachineInstance.InputTrigger(input_Trigger));
}
public void DiscoverChangeHandlerInvocations_SortTriggersByBaseTypeThenDerivedType()
{
var objectTrigger = new TriggerStub <object>();
var concreteTrigger = new TriggerStub <string>();
var serviceProvider = new ServiceCollection()
.AddSingleton <IBeforeSaveTrigger <string> >(concreteTrigger)
.AddSingleton <IBeforeSaveTrigger <object> >(objectTrigger)
.BuildServiceProvider();
var subject = new TriggerDiscoveryService(new TriggerServiceProviderAccessor(serviceProvider), new TriggerTypeRegistryService());
var result = subject.DiscoverTriggers(typeof(IBeforeSaveTrigger <>), typeof(string), type => new BeforeSaveTriggerDescriptor(type));
Assert.Equal(2, result.Count());
Assert.Equal(objectTrigger, result.First().Trigger);
Assert.Equal(concreteTrigger, result.Last().Trigger);
}
public void DiscoverChangeHandlerInvocations_SortTriggersByInterfaceThenType()
{
var interfaceTrigger = new TriggerStub <IComparable>();
var typeTrigger = new TriggerStub <string>();
var serviceProvider = new ServiceCollection()
.AddSingleton <IBeforeSaveTrigger <string> >(typeTrigger)
.AddSingleton <IBeforeSaveTrigger <IComparable> >(interfaceTrigger)
.BuildServiceProvider();
var subject = new TriggerDiscoveryService(new TriggerServiceProviderAccessor(serviceProvider), new TriggerTypeRegistryService());
var result = subject.DiscoverTriggers(typeof(IBeforeSaveTrigger <>), typeof(string), type => new BeforeSaveTriggerDescriptor(type));
Assert.Equal(2, result.Count());
Assert.Equal(interfaceTrigger, result.First().Trigger);
Assert.Equal(typeTrigger, result.Last().Trigger);
}
public void JobWasExecuted_ListenToJobs_ShouldUnwrapJobExecutionExceptionAndSchedulerException()
{
var emitted = ExecuteAndGetEvent(
new Quartz2SchedulerEventSource(true),
eventSource =>
{
var trigger = new TriggerStub("any");
eventSource.JobWasExecuted(
new JobExecutionContextStub
{
Trigger = trigger
},
new JobExecutionException("Error", new SchedulerException("Error", new Exception("Inner Exception Error"))));
});
Assert.That(emitted, Is.Not.Null);
Assert.That(emitted.Error, Is.Not.Null);
Assert.That(emitted.Error.Message, Is.EqualTo("Inner Exception Error"));
}
public void StartInitialisesTriggers()
{
var initialised = false;
var trigger = new TriggerStub
{
OnInitialise = () => initialised = true
};
var project = new ProjectStub("Test")
{
OnLoadState = () => { }
};
project.Triggers.Add(trigger);
project.Start();
// Give the project time to start
Thread.Sleep(100);
Assert.IsTrue(initialised);
}