public void Test_Complete_NullPerformer()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
procedureStep.Complete((Staff)null); // Perform event
}
public void Test_GetWorkflowHistory_TwoLevel()
{
// Testing an ideal 6 item Workflow history "tree"
var pRoot = new Procedure(); // associative Procedure to first level
var ps1 = new ConcreteProcedureStep(pRoot); // First level
var p1 = new Procedure(); // associative Procedure to left branch of second level
var ps11 = new ConcreteProcedureStep(p1); // Second level, left branch
var ps12 = new ConcreteProcedureStep(p1); // Second level, left branch
ps11.AddRelatedStep(ps12); // Relate children
ps1.LinkTo(ps11); // Link adjacent levels
var ps2 = new ConcreteProcedureStep(pRoot); // First level
var p2 = new Procedure(); // associative Procedure to right branch of second level
var ps21 = new ConcreteProcedureStep(p2); // Second level, right branch
var ps22 = new ConcreteProcedureStep(p2); // Second level, right branch
ps21.AddRelatedStep(ps22); // Relate children
ps2.LinkTo(ps21); // Link adjacent levels
Assert.AreEqual(6, pRoot.GetWorkflowHistory().Count); // Assert all items in "tree" are present in Workflow history
}
public void Test_Assign_NullStaff()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
// checking that assigning null has no effect if already null
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNull(procedureStep.Scheduling.Performer);
procedureStep.Assign((Staff)null);
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNull(procedureStep.Scheduling.Performer);
// check that assigning null has the effect of un-assiging if already assigned
Staff performer = new Staff();
procedureStep.Assign(performer);
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNotNull(procedureStep.Scheduling.Performer);
procedureStep.Assign((Staff)null);
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNull(procedureStep.Scheduling.Performer);
}
public void Test_PerformingStaff_PerformerNull()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Assert.IsNull(procedureStep.Performer);
Assert.IsNull(procedureStep.PerformingStaff);
}
public void Test_AssignedStaff_SchedulingNull()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Assert.IsFalse(procedureStep.Scheduling != null && procedureStep.Scheduling.Performer != null);
Assert.IsNull(procedureStep.AssignedStaff);
}
public void Test_Constructor()
{
Procedure procedure = new Procedure();
ProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Assert.AreEqual(procedure, procedureStep.Procedure);
Assert.IsTrue(procedure.ProcedureSteps.Contains(procedureStep));
}
public void Test_GetWorkflowHistory_UnrelatedSteps()
{
// This "tree" doesn't have the right children of each pair in the third level
// Due to the abscence of relating these steps
var pRoot = new Procedure(); // associative Procedure to first level
var ps1 = new ConcreteProcedureStep(pRoot);
var p1 = new Procedure(); // associative Procedure to left branch of second level
var ps11 = new ConcreteProcedureStep(p1);
var p11 = new Procedure(); // associative Procedure to leftmost branch of third level
var ps111 = new ConcreteProcedureStep(p11);
var ps112 = new ConcreteProcedureStep(p11); // is not related to ps111
ps11.LinkTo(ps111); // link adjacent levels
var ps12 = new ConcreteProcedureStep(p1);
var p12 = new Procedure(); // associative Procedure to second leftmost branch of third level
var ps121 = new ConcreteProcedureStep(p12);
var ps122 = new ConcreteProcedureStep(p12); // is not related to ps121
ps12.LinkTo(ps121); // link adjacent levels
ps11.AddRelatedStep(ps12); // relate steps of p1
ps1.LinkTo(ps11); // link adjacent levels
var ps2 = new ConcreteProcedureStep(pRoot);
var p2 = new Procedure(); // associative Procedure to right branch of second level
var ps21 = new ConcreteProcedureStep(p2);
var p21 = new Procedure(); // associative Procedure to second rightmost branch of third level
var ps211 = new ConcreteProcedureStep(p21);
var ps212 = new ConcreteProcedureStep(p21); // is not related to ps211
ps21.LinkTo(ps211); // link adjacent levels
var ps22 = new ConcreteProcedureStep(p2);
var p22 = new Procedure(); // associative Procedure to rightmost branch of third level
var ps221 = new ConcreteProcedureStep(p22);
var ps222 = new ConcreteProcedureStep(p22); // is not related to ps221
ps22.LinkTo(ps221); // link adjacent levels
ps21.AddRelatedStep(ps22); // relate steps of p2
ps2.LinkTo(ps21); // link adjacent levels
Assert.AreEqual(10, pRoot.GetWorkflowHistory().Count);
// Assert all items in "tree" are present in Workflow history... except these ones:
Assert.IsFalse(pRoot.GetWorkflowHistory().Contains(ps112));
Assert.IsFalse(pRoot.GetWorkflowHistory().Contains(ps122));
Assert.IsFalse(pRoot.GetWorkflowHistory().Contains(ps212));
Assert.IsFalse(pRoot.GetWorkflowHistory().Contains(ps222));
}
public void Test_DocumentationProcedureStep_Null()
{
var procedure = new Procedure();
var ps1 = new ConcreteProcedureStep(procedure);
var ps2 = new ConcreteReportingProcedureStep(procedure);
Assert.AreEqual(2, procedure.ProcedureSteps.Count);
Assert.IsNull(procedure.DocumentationProcedureStep);
}
public void Test_Reassign_Terminated()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
procedureStep.Discontinue();
ConcreteProcedureStep newStep = (ConcreteProcedureStep)procedureStep.Reassign(performer);
}
public void Test_PerformingStaff()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
procedureStep.Start(performer);
Assert.IsNotNull(procedureStep.Performer);
Assert.AreEqual(performer, procedureStep.PerformingStaff);
}
public void Test_GetWorkflowHistory_ThreeLevel()
{
var pRoot = new Procedure(); // associative Procedure to first level
var ps1 = new ConcreteProcedureStep(pRoot);
var p1 = new Procedure(); // associative Procedure to left branch of second level
var ps11 = new ConcreteProcedureStep(p1);
var p11 = new Procedure(); // associative Procedure to leftmost branch of third level
var ps111 = new ConcreteProcedureStep(p11);
var ps112 = new ConcreteProcedureStep(p11);
ps111.AddRelatedStep(ps112); // relate steps of p11
ps11.LinkTo(ps111); // link adjacent levels
var ps12 = new ConcreteProcedureStep(p1);
var p12 = new Procedure(); // associative Procedure to second leftmost branch of third level
var ps121 = new ConcreteProcedureStep(p12);
var ps122 = new ConcreteProcedureStep(p12);
ps121.AddRelatedStep(ps122); // relate steps of p12
ps12.LinkTo(ps121); // link adjacent levels
ps11.AddRelatedStep(ps12); // relate steps of p1
ps1.LinkTo(ps11); // link adjacent levels
var ps2 = new ConcreteProcedureStep(pRoot);
var p2 = new Procedure(); // associative Procedure to right branch of second level
var ps21 = new ConcreteProcedureStep(p2);
var p21 = new Procedure(); // associative Procedure to second rightmost branch of third level
var ps211 = new ConcreteProcedureStep(p21);
var ps212 = new ConcreteProcedureStep(p21);
ps211.AddRelatedStep(ps212); // relate steps of p21
ps21.LinkTo(ps211); // link adjacent levels
var ps22 = new ConcreteProcedureStep(p2);
var p22 = new Procedure(); // associative Procedure to rightmost branch of third level
var ps221 = new ConcreteProcedureStep(p22);
var ps222 = new ConcreteProcedureStep(p22);
ps221.AddRelatedStep(ps222); // relate steps of p22
ps22.LinkTo(ps221); // link adjacent levels
ps21.AddRelatedStep(ps22); // relate steps of p2
ps2.LinkTo(ps21); // link adjacent levels
Assert.AreEqual(14, pRoot.GetWorkflowHistory().Count); // Assert all items in "tree" are present in Workflow history
}
public void Test_LinkTo_LinkingNotSupported()
{
Procedure p1 = new Procedure();
Procedure p2 = new Procedure();
// create proc steps that don't support linking
ConcreteProcedureStep ps1 = new ConcreteProcedureStep(p1, false);
ConcreteProcedureStep ps2 = new ConcreteProcedureStep(p2, false);
// should throw, because linking is not supported
ps1.LinkTo(ps2);
}
public void Test_AssignedStaff()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
procedureStep.Assign(performer);
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNotNull(procedureStep.Scheduling.Performer);
Assert.AreEqual(performer, procedureStep.AssignedStaff);
}
public void Test_Cancel()
{
var procedure = new Procedure();
var ps = new ConcreteProcedureStep(procedure);
Assert.AreEqual(ProcedureStatus.SC, procedure.Status);
Assert.AreEqual(ActivityStatus.SC, ps.State);
Assert.IsFalse(ps.IsPreStep); // Only nPreStep will update procedure status
procedure.Cancel();
Assert.AreEqual(ActivityStatus.DC, ps.State);
Assert.AreEqual(ProcedureStatus.CA, procedure.Status);
}
public void Test_LinkTo()
{
Procedure p1 = new Procedure();
Procedure p2 = new Procedure();
// create proc steps that support linking
ConcreteProcedureStep ps1 = new ConcreteProcedureStep(p1, true);
ConcreteProcedureStep ps2 = new ConcreteProcedureStep(p2, true);
Assert.AreEqual(ActivityStatus.SC, ps1.State);
// pre-conditions:
// both link step properties are null (not set), and
// linked procedure lists are emtpy
Assert.IsNull(ps1.LinkStep);
Assert.IsFalse(ps1.IsLinked);
Assert.IsEmpty(ps1.GetLinkedProcedures());
Assert.IsNull(ps2.LinkStep);
Assert.IsFalse(ps2.IsLinked);
Assert.IsEmpty(ps2.GetLinkedProcedures());
// link step 1 to step 2
ps1.LinkTo(ps2);
// which should discontinue step 1
Assert.AreEqual(ActivityStatus.DC, ps1.State);
// expect the ps1.LinkStep is set to point to ps2
Assert.AreEqual(ps2, ps1.LinkStep);
Assert.IsTrue(ps1.IsLinked); // ps1 is linked
// expect ps1 does not have any linked procedures,
// and AllProcedures returns only ps1
Assert.IsEmpty(ps1.GetLinkedProcedures());
Assert.AreEqual(1, ps1.AllProcedures.Count);
Assert.Contains(p1, ps1.AllProcedures);
// expect ps2 is still not linked
Assert.IsNull(ps2.LinkStep);
Assert.IsFalse(ps2.IsLinked); // ps2 is not linked
// expect ps2 has exactly 1 linked procedure, which is p1
Assert.AreEqual(1, ps2.GetLinkedProcedures().Count);
Assert.Contains(p1, ps2.GetLinkedProcedures());
// expect AllProcedures contains both p1 and p2
Assert.AreEqual(2, ps2.AllProcedures.Count);
Assert.Contains(p1, ps2.AllProcedures);
Assert.Contains(p2, ps2.AllProcedures);
}
public void Test_LinkTo_StateNotScheduled()
{
Procedure p1 = new Procedure();
Procedure p2 = new Procedure();
// create proc steps that support linking
ConcreteProcedureStep ps1 = new ConcreteProcedureStep(p1, true);
ConcreteProcedureStep ps2 = new ConcreteProcedureStep(p2, true);
ps1.Discontinue();
Assert.AreEqual(ActivityStatus.DC, ps1.State);
// should throw, because only a scheduled step can be linked to another
ps1.LinkTo(ps2);
}
public void Test_Complete()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
Assert.AreEqual(ActivityStatus.SC, procedureStep.State);
procedureStep.Complete(performer); // Perform event
// Make assertions
Assert.AreEqual(ActivityStatus.CM, procedureStep.State);
Assert.IsTrue(RoughlyEqual(Platform.Time, procedureStep.EndTime));
Assert.IsInstanceOf(typeof(ProcedureStepPerformer), procedureStep.Performer);
Assert.AreEqual(performer, ((ProcedureStepPerformer)procedureStep.Performer).Staff);
}
public void Test_Assign()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNull(procedureStep.Scheduling.Performer);
procedureStep.Assign(performer);
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNotNull(procedureStep.Scheduling.Performer);
Assert.IsInstanceOf(typeof(ProcedureStepPerformer), procedureStep.Scheduling.Performer);
Assert.AreEqual(performer, ((ProcedureStepPerformer)procedureStep.Scheduling.Performer).Staff);
}
public void Test_Reassign_Scheduled()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNull(procedureStep.Scheduling.Performer);
ConcreteProcedureStep newStep = (ConcreteProcedureStep)procedureStep.Reassign(performer); // Perform event
// Make assertions
Assert.IsNotNull(newStep.Scheduling);
Assert.IsNotNull(newStep.Scheduling.Performer);
Assert.IsInstanceOf(typeof(ProcedureStepPerformer), newStep.Scheduling.Performer);
Assert.AreEqual(performer, ((ProcedureStepPerformer)newStep.Scheduling.Performer).Staff);
}
public void Test_Start()
{
DateTime? later = DateTime.Now.AddHours(2);
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
Assert.AreEqual(ActivityStatus.SC, procedureStep.State);
procedureStep.Start(performer, later);// Perform event
// Make assertions
Assert.AreEqual(ActivityStatus.IP, procedureStep.State);
Assert.AreEqual(later, procedureStep.StartTime);
Assert.IsInstanceOf(typeof(ProcedureStepPerformer), procedureStep.Performer);
Assert.AreEqual(performer, ((ProcedureStepPerformer)procedureStep.Performer).Staff);
}
public void Test_GetRelatedProcedureSteps()
{
Procedure p1 = new Procedure();
// attach 2 procedure steps to p1
ConcreteProcedureStep ps11 = new ConcreteProcedureStep(p1, false);
ConcreteProcedureStep ps12 = new ConcreteProcedureStep(p1, false);
// expect that each ps is only related to itself
Assert.AreEqual(1, ps11.GetRelatedProcedureSteps().Count);
Assert.Contains(ps11, ps11.GetRelatedProcedureSteps());
Assert.AreEqual(1, ps12.GetRelatedProcedureSteps().Count);
Assert.Contains(ps12, ps12.GetRelatedProcedureSteps());
// now set ps12 related to ps11
ps11.SetRelatedSteps(
new ConcreteProcedureStep[] { ps12 });
// expect ps11 now has 2 related steps, itself and ps12
Assert.AreEqual(2, ps11.GetRelatedProcedureSteps().Count);
Assert.Contains(ps11, ps11.GetRelatedProcedureSteps());
Assert.Contains(ps12, ps11.GetRelatedProcedureSteps());
// create another procedure and proc step
Procedure p2 = new Procedure();
ConcreteProcedureStep ps21 = new ConcreteProcedureStep(p2, false);
// now set ps21 related to ps11
ps11.SetRelatedSteps(
new ConcreteProcedureStep[] { ps21 });
// expect that ps11 is only related to itself,
// (eg ps21 has no effect, because it is associated with a different procedure,
// and only steps associated to the same procedure can be related.
Assert.AreEqual(1, ps11.GetRelatedProcedureSteps().Count);
Assert.Contains(ps11, ps11.GetRelatedProcedureSteps());
}
public void Test_Reassign_InProgressOrSuspended()
{
DateTime? now = DateTime.Now;
DateTime? end = now + TimeSpan.FromDays(3);
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
procedureStep.Schedule(now, end);
procedureStep.Suspend();
Assert.AreEqual(ActivityStatus.SU, procedureStep.State);
ConcreteProcedureStep newStep = (ConcreteProcedureStep)procedureStep.Reassign(performer); // Perform event
// Make assertions
Assert.AreEqual(ActivityStatus.DC, procedureStep.State);
Assert.AreEqual(ActivityStatus.SC, newStep.State);
Assert.AreEqual(now, newStep.Scheduling.StartTime);
Assert.AreEqual(end, newStep.Scheduling.EndTime);
Assert.IsNotNull(newStep.Scheduling);
Assert.IsNotNull(newStep.Scheduling.Performer);
Assert.IsInstanceOf(typeof(ProcedureStepPerformer), newStep.Scheduling.Performer);
Assert.AreEqual(performer, ((ProcedureStepPerformer)newStep.Scheduling.Performer).Staff);
}
public void Test_PerformingStaff_PerformerNull()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Assert.IsNull(procedureStep.Performer);
Assert.IsNull(procedureStep.PerformingStaff);
}
public void Test_PerformingStaff()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
procedureStep.Start(performer);
Assert.IsNotNull(procedureStep.Performer);
Assert.AreEqual(performer, procedureStep.PerformingStaff);
}
public void Test_Complete_NullPerformer()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
procedureStep.Complete((Staff)null); // Perform event
}
public void Test_GetWorkflowHistory_ThreeLevel()
{
var pRoot = new Procedure(); // associative Procedure to first level
var ps1 = new ConcreteProcedureStep(pRoot);
var p1 = new Procedure(); // associative Procedure to left branch of second level
var ps11 = new ConcreteProcedureStep(p1);
var p11 = new Procedure(); // associative Procedure to leftmost branch of third level
var ps111 = new ConcreteProcedureStep(p11);
var ps112 = new ConcreteProcedureStep(p11);
ps111.AddRelatedStep(ps112); // relate steps of p11
ps11.LinkTo(ps111); // link adjacent levels
var ps12 = new ConcreteProcedureStep(p1);
var p12 = new Procedure(); // associative Procedure to second leftmost branch of third level
var ps121 = new ConcreteProcedureStep(p12);
var ps122 = new ConcreteProcedureStep(p12);
ps121.AddRelatedStep(ps122); // relate steps of p12
ps12.LinkTo(ps121); // link adjacent levels
ps11.AddRelatedStep(ps12); // relate steps of p1
ps1.LinkTo(ps11); // link adjacent levels
var ps2 = new ConcreteProcedureStep(pRoot);
var p2 = new Procedure(); // associative Procedure to right branch of second level
var ps21 = new ConcreteProcedureStep(p2);
var p21 = new Procedure(); // associative Procedure to second rightmost branch of third level
var ps211 = new ConcreteProcedureStep(p21);
var ps212 = new ConcreteProcedureStep(p21);
ps211.AddRelatedStep(ps212); // relate steps of p21
ps21.LinkTo(ps211); // link adjacent levels
var ps22 = new ConcreteProcedureStep(p2);
var p22 = new Procedure(); // associative Procedure to rightmost branch of third level
var ps221 = new ConcreteProcedureStep(p22);
var ps222 = new ConcreteProcedureStep(p22);
ps221.AddRelatedStep(ps222); // relate steps of p22
ps22.LinkTo(ps221); // link adjacent levels
ps21.AddRelatedStep(ps22); // relate steps of p2
ps2.LinkTo(ps21); // link adjacent levels
Assert.AreEqual(14, pRoot.GetWorkflowHistory().Count); // Assert all items in "tree" are present in Workflow history
}
/// <summary>
/// Method used to set the "related" steps, for testing
/// </summary>
/// <param name="relatedSteps"></param>
public void SetRelatedSteps(ConcreteProcedureStep[] relatedSteps)
{
_relatedSteps = new List<ProcedureStep>(relatedSteps);
}
public void Test_LinkTo_LinkingNotSupported()
{
Procedure p1 = new Procedure();
Procedure p2 = new Procedure();
// create proc steps that don't support linking
ConcreteProcedureStep ps1 = new ConcreteProcedureStep(p1, false);
ConcreteProcedureStep ps2 = new ConcreteProcedureStep(p2, false);
// should throw, because linking is not supported
ps1.LinkTo(ps2);
}
public void Test_Reassign_Terminated()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
procedureStep.Discontinue();
ConcreteProcedureStep newStep = (ConcreteProcedureStep)procedureStep.Reassign(performer);
}
public void Test_DocumentationProcedureStep_Null()
{
var procedure = new Procedure();
var ps1 = new ConcreteProcedureStep(procedure);
var ps2 = new ConcreteReportingProcedureStep(procedure);
Assert.AreEqual(2, procedure.ProcedureSteps.Count);
Assert.IsNull(procedure.DocumentationProcedureStep);
}
public void Test_Assign_NullStaff()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
// checking that assigning null has no effect if already null
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNull(procedureStep.Scheduling.Performer);
procedureStep.Assign((Staff)null);
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNull(procedureStep.Scheduling.Performer);
// check that assigning null has the effect of un-assiging if already assigned
Staff performer = new Staff();
procedureStep.Assign(performer);
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNotNull(procedureStep.Scheduling.Performer);
procedureStep.Assign((Staff)null);
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNull(procedureStep.Scheduling.Performer);
}
public void Test_Assign()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNull(procedureStep.Scheduling.Performer);
procedureStep.Assign(performer);
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNotNull(procedureStep.Scheduling.Performer);
Assert.IsInstanceOfType(typeof(ProcedureStepPerformer), procedureStep.Scheduling.Performer);
Assert.AreEqual(performer, ((ProcedureStepPerformer)procedureStep.Scheduling.Performer).Staff);
}
public void Test_Cancel()
{
var procedure = new Procedure();
var ps = new ConcreteProcedureStep(procedure);
Assert.AreEqual(ProcedureStatus.SC, procedure.Status);
Assert.AreEqual(ActivityStatus.SC, ps.State);
Assert.IsFalse(ps.IsPreStep); // Only nPreStep will update procedure status
procedure.Cancel();
Assert.AreEqual(ActivityStatus.DC, ps.State);
Assert.AreEqual(ProcedureStatus.CA, procedure.Status);
}
public void Test_GetWorkflowHistory_UnrelatedSteps()
{
// This "tree" doesn't have the right children of each pair in the third level
// Due to the abscence of relating these steps
var pRoot = new Procedure(); // associative Procedure to first level
var ps1 = new ConcreteProcedureStep(pRoot);
var p1 = new Procedure(); // associative Procedure to left branch of second level
var ps11 = new ConcreteProcedureStep(p1);
var p11 = new Procedure(); // associative Procedure to leftmost branch of third level
var ps111 = new ConcreteProcedureStep(p11);
var ps112 = new ConcreteProcedureStep(p11); // is not related to ps111
ps11.LinkTo(ps111); // link adjacent levels
var ps12 = new ConcreteProcedureStep(p1);
var p12 = new Procedure(); // associative Procedure to second leftmost branch of third level
var ps121 = new ConcreteProcedureStep(p12);
var ps122 = new ConcreteProcedureStep(p12); // is not related to ps121
ps12.LinkTo(ps121); // link adjacent levels
ps11.AddRelatedStep(ps12); // relate steps of p1
ps1.LinkTo(ps11); // link adjacent levels
var ps2 = new ConcreteProcedureStep(pRoot);
var p2 = new Procedure(); // associative Procedure to right branch of second level
var ps21 = new ConcreteProcedureStep(p2);
var p21 = new Procedure(); // associative Procedure to second rightmost branch of third level
var ps211 = new ConcreteProcedureStep(p21);
var ps212 = new ConcreteProcedureStep(p21); // is not related to ps211
ps21.LinkTo(ps211); // link adjacent levels
var ps22 = new ConcreteProcedureStep(p2);
var p22 = new Procedure(); // associative Procedure to rightmost branch of third level
var ps221 = new ConcreteProcedureStep(p22);
var ps222 = new ConcreteProcedureStep(p22); // is not related to ps221
ps22.LinkTo(ps221); // link adjacent levels
ps21.AddRelatedStep(ps22); // relate steps of p2
ps2.LinkTo(ps21); // link adjacent levels
Assert.AreEqual(10, pRoot.GetWorkflowHistory().Count);
// Assert all items in "tree" are present in Workflow history... except these ones:
Assert.IsFalse(pRoot.GetWorkflowHistory().Contains(ps112));
Assert.IsFalse(pRoot.GetWorkflowHistory().Contains(ps122));
Assert.IsFalse(pRoot.GetWorkflowHistory().Contains(ps212));
Assert.IsFalse(pRoot.GetWorkflowHistory().Contains(ps222));
}
public void Test_LinkTo()
{
Procedure p1 = new Procedure();
Procedure p2 = new Procedure();
// create proc steps that support linking
ConcreteProcedureStep ps1 = new ConcreteProcedureStep(p1, true);
ConcreteProcedureStep ps2 = new ConcreteProcedureStep(p2, true);
Assert.AreEqual(ActivityStatus.SC, ps1.State);
// pre-conditions:
// both link step properties are null (not set), and
// linked procedure lists are emtpy
Assert.IsNull(ps1.LinkStep);
Assert.IsFalse(ps1.IsLinked);
Assert.IsEmpty(ps1.GetLinkedProcedures());
Assert.IsNull(ps2.LinkStep);
Assert.IsFalse(ps2.IsLinked);
Assert.IsEmpty(ps2.GetLinkedProcedures());
// link step 1 to step 2
ps1.LinkTo(ps2);
// which should discontinue step 1
Assert.AreEqual(ActivityStatus.DC, ps1.State);
// expect the ps1.LinkStep is set to point to ps2
Assert.AreEqual(ps2, ps1.LinkStep);
Assert.IsTrue(ps1.IsLinked); // ps1 is linked
// expect ps1 does not have any linked procedures,
// and AllProcedures returns only ps1
Assert.IsEmpty(ps1.GetLinkedProcedures());
Assert.AreEqual(1, ps1.AllProcedures.Count);
Assert.Contains(p1, ps1.AllProcedures);
// expect ps2 is still not linked
Assert.IsNull(ps2.LinkStep);
Assert.IsFalse(ps2.IsLinked); // ps2 is not linked
// expect ps2 has exactly 1 linked procedure, which is p1
Assert.AreEqual(1, ps2.GetLinkedProcedures().Count);
Assert.Contains(p1, ps2.GetLinkedProcedures());
// expect AllProcedures contains both p1 and p2
Assert.AreEqual(2, ps2.AllProcedures.Count);
Assert.Contains(p1, ps2.AllProcedures);
Assert.Contains(p2, ps2.AllProcedures);
}
public void Test_LinkTo_StateNotScheduled()
{
Procedure p1 = new Procedure();
Procedure p2 = new Procedure();
// create proc steps that support linking
ConcreteProcedureStep ps1 = new ConcreteProcedureStep(p1, true);
ConcreteProcedureStep ps2 = new ConcreteProcedureStep(p2, true);
ps1.Discontinue();
Assert.AreEqual(ActivityStatus.DC, ps1.State);
// should throw, because only a scheduled step can be linked to another
ps1.LinkTo(ps2);
}
public void Test_AssignedStaff()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
procedureStep.Assign(performer);
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNotNull(procedureStep.Scheduling.Performer);
Assert.AreEqual(performer, procedureStep.AssignedStaff);
}
public void Test_GetRelatedProcedureSteps()
{
Procedure p1 = new Procedure();
// attach 2 procedure steps to p1
ConcreteProcedureStep ps11 = new ConcreteProcedureStep(p1, false);
ConcreteProcedureStep ps12 = new ConcreteProcedureStep(p1, false);
// expect that each ps is only related to itself
Assert.AreEqual(1, ps11.GetRelatedProcedureSteps().Count);
Assert.Contains(ps11, ps11.GetRelatedProcedureSteps());
Assert.AreEqual(1, ps12.GetRelatedProcedureSteps().Count);
Assert.Contains(ps12, ps12.GetRelatedProcedureSteps());
// now set ps12 related to ps11
ps11.SetRelatedSteps(
new ConcreteProcedureStep[]{ps12});
// expect ps11 now has 2 related steps, itself and ps12
Assert.AreEqual(2, ps11.GetRelatedProcedureSteps().Count);
Assert.Contains(ps11, ps11.GetRelatedProcedureSteps());
Assert.Contains(ps12, ps11.GetRelatedProcedureSteps());
// create another procedure and proc step
Procedure p2 = new Procedure();
ConcreteProcedureStep ps21 = new ConcreteProcedureStep(p2, false);
// now set ps21 related to ps11
ps11.SetRelatedSteps(
new ConcreteProcedureStep[] { ps21 });
// expect that ps11 is only related to itself,
// (eg ps21 has no effect, because it is associated with a different procedure,
// and only steps associated to the same procedure can be related.
Assert.AreEqual(1, ps11.GetRelatedProcedureSteps().Count);
Assert.Contains(ps11, ps11.GetRelatedProcedureSteps());
}
public void Test_AssignedStaff_SchedulingNull()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Assert.IsFalse(procedureStep.Scheduling != null && procedureStep.Scheduling.Performer != null);
Assert.IsNull(procedureStep.AssignedStaff);
}
public void Test_Start()
{
DateTime? later = DateTime.Now.AddHours(2);
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
Assert.AreEqual(ActivityStatus.SC, procedureStep.State);
procedureStep.Start(performer, later);// Perform event
// Make assertions
Assert.AreEqual(ActivityStatus.IP, procedureStep.State);
Assert.AreEqual(later, procedureStep.StartTime);
Assert.IsInstanceOfType(typeof(ProcedureStepPerformer), procedureStep.Performer);
Assert.AreEqual(performer, ((ProcedureStepPerformer)procedureStep.Performer).Staff);
}
public void Test_Complete()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
Assert.AreEqual(ActivityStatus.SC, procedureStep.State);
procedureStep.Complete(performer); // Perform event
// Make assertions
Assert.AreEqual(ActivityStatus.CM, procedureStep.State);
Assert.IsTrue(RoughlyEqual(Platform.Time, procedureStep.EndTime));
Assert.IsInstanceOfType(typeof(ProcedureStepPerformer), procedureStep.Performer);
Assert.AreEqual(performer, ((ProcedureStepPerformer)procedureStep.Performer).Staff);
}
public void Test_Reassign_Scheduled()
{
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
Assert.IsNotNull(procedureStep.Scheduling);
Assert.IsNull(procedureStep.Scheduling.Performer);
ConcreteProcedureStep newStep = (ConcreteProcedureStep)procedureStep.Reassign(performer); // Perform event
// Make assertions
Assert.IsNotNull(newStep.Scheduling);
Assert.IsNotNull(newStep.Scheduling.Performer);
Assert.IsInstanceOfType(typeof(ProcedureStepPerformer), newStep.Scheduling.Performer);
Assert.AreEqual(performer, ((ProcedureStepPerformer)newStep.Scheduling.Performer).Staff);
}
public void Test_GetWorkflowHistory_TwoLevel()
{
// Testing an ideal 6 item Workflow history "tree"
var pRoot = new Procedure(); // associative Procedure to first level
var ps1 = new ConcreteProcedureStep(pRoot); // First level
var p1 = new Procedure(); // associative Procedure to left branch of second level
var ps11 = new ConcreteProcedureStep(p1); // Second level, left branch
var ps12 = new ConcreteProcedureStep(p1); // Second level, left branch
ps11.AddRelatedStep(ps12); // Relate children
ps1.LinkTo(ps11); // Link adjacent levels
var ps2 = new ConcreteProcedureStep(pRoot); // First level
var p2 = new Procedure(); // associative Procedure to right branch of second level
var ps21 = new ConcreteProcedureStep(p2); // Second level, right branch
var ps22 = new ConcreteProcedureStep(p2); // Second level, right branch
ps21.AddRelatedStep(ps22); // Relate children
ps2.LinkTo(ps21); // Link adjacent levels
Assert.AreEqual(6, pRoot.GetWorkflowHistory().Count); // Assert all items in "tree" are present in Workflow history
}
public void Test_Constructor()
{
Procedure procedure = new Procedure();
ProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Assert.AreEqual(procedure, procedureStep.Procedure);
Assert.IsTrue(procedure.ProcedureSteps.Contains(procedureStep));
}
public void Test_Reassign_InProgressOrSuspended()
{
DateTime? now = DateTime.Now;
DateTime? end = now + TimeSpan.FromDays(3);
Procedure procedure = new Procedure();
ConcreteProcedureStep procedureStep = new ConcreteProcedureStep(procedure);
Staff performer = new Staff();
procedureStep.Schedule(now, end);
procedureStep.Suspend();
Assert.AreEqual(ActivityStatus.SU, procedureStep.State);
ConcreteProcedureStep newStep = (ConcreteProcedureStep)procedureStep.Reassign(performer); // Perform event
// Make assertions
Assert.AreEqual(ActivityStatus.DC, procedureStep.State);
Assert.AreEqual(ActivityStatus.SC, newStep.State);
Assert.AreEqual(now, newStep.Scheduling.StartTime);
Assert.AreEqual(end, newStep.Scheduling.EndTime);
Assert.IsNotNull(newStep.Scheduling);
Assert.IsNotNull(newStep.Scheduling.Performer);
Assert.IsInstanceOfType(typeof(ProcedureStepPerformer), newStep.Scheduling.Performer);
Assert.AreEqual(performer, ((ProcedureStepPerformer)newStep.Scheduling.Performer).Staff);
}
