Example #1
0
        public void Test_IsTerminatedTrue()
        {
            var procedure = new Procedure();

            procedure.Cancel();

            Assert.AreEqual(ProcedureStatus.CA, procedure.Status);
            Assert.IsTrue(procedure.IsTerminated);

            procedure = new Procedure();
            var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());

            procedureStep.Start(new Staff());
            procedure.Complete(Platform.Time);

            Assert.AreEqual(ProcedureStatus.CM, procedure.Status);
            Assert.IsTrue(procedure.IsTerminated);

            procedure     = new Procedure();
            procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
            procedureStep.Start(new Staff());
            procedure.Discontinue();

            Assert.AreEqual(ProcedureStatus.DC, procedure.Status);
            Assert.IsTrue(procedure.IsTerminated);
        }
Example #2
0
        public void Test_PerformedTime()
        {
            var procedure = new Procedure();

            var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());

            ps1.Start(new Staff());
            ps1.Complete(Platform.Time);

            var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());

            ps2.Start(new Staff());
            ps2.Complete(Platform.Time + TimeSpan.FromDays(1));

            var ps3 = new ModalityProcedureStep(procedure, "ps3", new Modality());

            ps3.Start(new Staff());
            ps3.Complete(Platform.Time + TimeSpan.FromDays(2));

            var ps4 = new ModalityProcedureStep(procedure, "ps4", new Modality());

            ps4.Start(new Staff());
            ps4.Complete(Platform.Time + TimeSpan.FromDays(3));

            Assert.AreEqual(ps4.EndTime, procedure.PerformedTime);
        }
Example #3
0
        public void Test_IsPerformed()
        {
            var procedure = new Procedure();
            var ps1       = new ModalityProcedureStep(procedure, "ps1", new Modality());
            var ps2       = new ModalityProcedureStep(procedure, "ps2", new Modality());
            var ps3       = new ModalityProcedureStep(procedure, "ps3", new Modality());

            Assert.IsFalse(procedure.IsPerformed);

            ps1.Start(new Staff());
            Assert.IsFalse(procedure.IsPerformed);

            ps1.Complete(Platform.Time);
            Assert.IsFalse(procedure.IsPerformed);

            ps2.Start(new Staff());
            ps3.Start(new Staff());
            Assert.IsFalse(procedure.IsPerformed);

            ps2.Discontinue();
            Assert.IsFalse(procedure.IsPerformed);

            ps3.Complete();
            Assert.IsTrue(procedure.IsPerformed);
        }
        public void Test_CompleteProcedureStepFromInProgress()
        {
            Order                 order = TestOrderFactory.CreateOrder(1, 1, true);
            Procedure             rp1   = CollectionUtils.FirstElement(order.Procedures);
            ModalityProcedureStep mps1  = rp1.ModalityProcedureSteps[0];

            CheckStatus(ActivityStatus.SC, mps1);

            mps1.Start(TestStaffFactory.CreateStaff(new StaffTypeEnum("STEC", null, null)));

            CheckStatus(ActivityStatus.IP, mps1);

            mps1.Complete();

            CheckStatus(ActivityStatus.CM, mps1);
            Assert.IsNotNull(mps1.StartTime);
            Assert.IsNotNull(mps1.EndTime);

            CheckStatus(ProcedureStatus.IP, rp1);
            Assert.IsNotNull(rp1.StartTime);
            Assert.IsNull(rp1.EndTime);

            CheckStatus(OrderStatus.IP, order);
            Assert.IsNotNull(order.StartTime);
            Assert.IsNull(order.EndTime);
        }
Example #5
0
        public void Test_Schedule_InProgress()
        {
            var procedure = new Procedure();
            var ps        = new ModalityProcedureStep(procedure, "New modality.", new Modality());

            ps.Start(new Staff());
            Assert.AreEqual(ProcedureStatus.IP, procedure.Status);

            procedure.Schedule(Platform.Time);
        }
Example #6
0
        public void Test_Cancel_InProgress()
        {
            var procedure = new Procedure();
            var ps        = new ModalityProcedureStep(procedure, "New modality.", new Modality());

            ps.Start(new Staff());
            Assert.AreEqual(ProcedureStatus.IP, procedure.Status);

            procedure.Cancel();
        }
Example #7
0
        public void Test_IsPerformed_NonePerformed()
        {
            var procedure = new Procedure();
            var ps1       = new ModalityProcedureStep(procedure, "ps1", new Modality());

            ps1.Start(new Staff());

            var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());

            Assert.IsFalse(procedure.IsPerformed);
        }
Example #8
0
        public void Test_Schedule_Complete()
        {
            var procedure = new Procedure();
            var ps        = new ModalityProcedureStep(procedure, "New modality.", new Modality());

            ps.Start(new Staff());
            procedure.Complete(DateTime.Now);
            Assert.AreEqual(ProcedureStatus.CM, procedure.Status);

            procedure.Schedule(Platform.Time);
        }
Example #9
0
        public void Test_Cancel_Discontinued()
        {
            var procedure = new Procedure();
            var ps        = new ModalityProcedureStep(procedure, "New modality.", new Modality());

            ps.Start(new Staff());
            procedure.Discontinue();
            Assert.AreEqual(ProcedureStatus.DC, procedure.Status);

            procedure.Cancel();
        }
Example #10
0
        public void Test_Cancel_Completed()
        {
            var procedure = new Procedure();
            var ps        = new ModalityProcedureStep(procedure, "New modality.", new Modality());

            ps.Start(new Staff());
            procedure.Complete(DateTime.Now);
            Assert.AreEqual(ProcedureStatus.CM, procedure.Status);

            procedure.Cancel();
        }
Example #11
0
        public void Test_AddProcedureStep_StepNotScheduling()
        {
            var procedure     = new Procedure();
            var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());

            procedureStep.Start(new Staff());

            Assert.AreEqual(ActivityStatus.IP, procedureStep.State);

            procedure.AddProcedureStep(procedureStep);
        }
Example #12
0
        public void Test_IsTerminatedFalse()
        {
            var procedure = new Procedure();

            Assert.IsFalse(procedure.IsTerminated);

            var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());

            procedureStep.Start(new Staff());

            Assert.IsFalse(procedure.IsTerminated);
        }
Example #13
0
        public void Test_CanExecute_InProgress()
        {
            Order order = new Order();
            CancelOrderOperation  op        = new CancelOrderOperation();
            Procedure             procedure = new Procedure();
            ModalityProcedureStep step      = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());

            order.AddProcedure(procedure);

            step.Start(new Staff());
            Assert.AreEqual(OrderStatus.IP, order.Status);

            Assert.IsFalse(op.CanExecute(order));
        }
Example #14
0
        public void Test_Execute_InProgress()
        {
            Order order = new Order();
            OrderCancelInfo info = new OrderCancelInfo();
            CancelOrderOperation op = new CancelOrderOperation();
            Procedure procedure = new Procedure();
            ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
            order.AddProcedure(procedure);

            step.Start(new Staff());
            Assert.AreEqual(OrderStatus.IP, order.Status);

            op.Execute(order, info);
        }
Example #15
0
        public void Discontinue()
        {
            var procedure     = new Procedure();
            var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());

            procedureStep.Start(new Staff());

            Assert.AreEqual(ProcedureStatus.IP, procedure.Status);
            Assert.AreEqual(ActivityStatus.IP, procedureStep.State);

            procedure.Discontinue();

            Assert.AreEqual(ProcedureStatus.DC, procedure.Status);
            Assert.AreEqual(ActivityStatus.DC, procedureStep.State);
        }
        public void Test_Execute()
        {
            Order                     order     = new Order();
            OrderCancelInfo           info      = new OrderCancelInfo();
            DiscontinueOrderOperation op        = new DiscontinueOrderOperation();
            Procedure                 procedure = new Procedure();
            ModalityProcedureStep     step      = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());

            order.AddProcedure(procedure);

            step.Start(new Staff());
            Assert.AreEqual(OrderStatus.IP, order.Status);

            op.Execute(order, info);
        }
        public void Test_CanExecute_Complete()
        {
            Order order = new Order();
            DiscontinueOrderOperation op    = new DiscontinueOrderOperation();
            Procedure             procedure = new Procedure();
            ModalityProcedureStep step      = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());

            order.AddProcedure(procedure);

            step.Start(new Staff());
            procedure.Complete(DateTime.Now);
            order.UpdateStatus();
            Assert.AreEqual(OrderStatus.CM, order.Status);

            Assert.IsFalse(op.CanExecute(order));
        }
        public void Test_Execute_Complete()
        {
            Order order = new Order();
            OrderCancelInfo info = new OrderCancelInfo();
            DiscontinueOrderOperation op = new DiscontinueOrderOperation();
            Procedure procedure = new Procedure();
            ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
            order.AddProcedure(procedure);

            step.Start(new Staff());
            procedure.Complete(DateTime.Now);
            order.UpdateStatus();
            Assert.AreEqual(OrderStatus.CM, order.Status);

            op.Execute(order, info);
        }
Example #19
0
        public void Test_Execute_Complete()
        {
            Order                 order     = new Order();
            OrderCancelInfo       info      = new OrderCancelInfo();
            CancelOrderOperation  op        = new CancelOrderOperation();
            Procedure             procedure = new Procedure();
            ModalityProcedureStep step      = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());

            order.AddProcedure(procedure);

            step.Start(new Staff());
            procedure.Complete(DateTime.Now);
            order.UpdateStatus();
            Assert.AreEqual(OrderStatus.CM, order.Status);

            op.Execute(order, info);
        }
Example #20
0
        public void Test_CanExecute_Discontinue()
        {
            Order order = new Order();
            CancelOrderOperation op = new CancelOrderOperation();
            Procedure procedure = new Procedure();
            ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
            order.AddProcedure(procedure);

            step.Start(new Staff());
            order.Discontinue(new OrderCancelInfo());
            Assert.AreEqual(OrderStatus.DC, order.Status);

            Assert.IsFalse(op.CanExecute(order));
        }
Example #21
0
		public void Test_IsTerminatedFalse()
		{
			var procedure = new Procedure();

			Assert.IsFalse(procedure.IsTerminated);

			var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
			procedureStep.Start(new Staff());

			Assert.IsFalse(procedure.IsTerminated);
		}
Example #22
0
		public void Test_PerformedTime()
		{
			var procedure = new Procedure();

			var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
			ps1.Start(new Staff());
			ps1.Complete(Platform.Time);

			var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());
			ps2.Start(new Staff());
			ps2.Complete(Platform.Time + TimeSpan.FromDays(1));

			var ps3 = new ModalityProcedureStep(procedure, "ps3", new Modality());
			ps3.Start(new Staff());
			ps3.Complete(Platform.Time + TimeSpan.FromDays(2));

			var ps4 = new ModalityProcedureStep(procedure, "ps4", new Modality());
			ps4.Start(new Staff());
			ps4.Complete(Platform.Time + TimeSpan.FromDays(3));

			Assert.AreEqual(ps4.EndTime, procedure.PerformedTime);
		}
Example #23
0
		public void Test_IsPerformed()
		{
			var procedure = new Procedure();
			var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
			var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());
			var ps3 = new ModalityProcedureStep(procedure, "ps3", new Modality());

			Assert.IsFalse(procedure.IsPerformed);

			ps1.Start(new Staff());
			Assert.IsFalse(procedure.IsPerformed);

			ps1.Complete(Platform.Time);
			Assert.IsFalse(procedure.IsPerformed);

			ps2.Start(new Staff());
			ps3.Start(new Staff());
			Assert.IsFalse(procedure.IsPerformed);

			ps2.Discontinue();
			Assert.IsFalse(procedure.IsPerformed);

			ps3.Complete();
			Assert.IsTrue(procedure.IsPerformed);
		}
Example #24
0
		public void Test_IsPerformed_NonePerformed()
		{
			var procedure = new Procedure();
			var ps1 = new ModalityProcedureStep(procedure, "ps1", new Modality());
			ps1.Start(new Staff());

			var ps2 = new ModalityProcedureStep(procedure, "ps2", new Modality());

			Assert.IsFalse(procedure.IsPerformed);
		}
Example #25
0
		public void Test_AddProcedureStep_StepNotScheduling()
		{
			var procedure = new Procedure();
			var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
			procedureStep.Start(new Staff());

			Assert.AreEqual(ActivityStatus.IP, procedureStep.State);

			procedure.AddProcedureStep(procedureStep);
		}
Example #26
0
		public void Test_Schedule_InProgress()
		{
			var procedure = new Procedure();
			var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
			ps.Start(new Staff());
			Assert.AreEqual(ProcedureStatus.IP, procedure.Status);

			procedure.Schedule(Platform.Time);
		}
Example #27
0
		public void Test_Schedule_Complete()
		{
			var procedure = new Procedure();
			var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
			ps.Start(new Staff());
			procedure.Complete(DateTime.Now);
			Assert.AreEqual(ProcedureStatus.CM, procedure.Status);

			procedure.Schedule(Platform.Time);
		}
Example #28
0
		public void Discontinue()
		{
			var procedure = new Procedure();
			var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
			procedureStep.Start(new Staff());

			Assert.AreEqual(ProcedureStatus.IP, procedure.Status);
			Assert.AreEqual(ActivityStatus.IP, procedureStep.State);

			procedure.Discontinue();

			Assert.AreEqual(ProcedureStatus.DC, procedure.Status);
			Assert.AreEqual(ActivityStatus.DC, procedureStep.State);
		}
Example #29
0
		public void Test_Cancel_InProgress()
		{
			var procedure = new Procedure();
			var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
			ps.Start(new Staff());
			Assert.AreEqual(ProcedureStatus.IP, procedure.Status);

			procedure.Cancel();
		}
Example #30
0
		public void Test_Cancel_Discontinued()
		{
			var procedure = new Procedure();
			var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
			ps.Start(new Staff());
			procedure.Discontinue();
			Assert.AreEqual(ProcedureStatus.DC, procedure.Status);

			procedure.Cancel();
		}
Example #31
0
		public void Test_Cancel_Completed()
		{
			var procedure = new Procedure();
			var ps = new ModalityProcedureStep(procedure, "New modality.", new Modality());
			ps.Start(new Staff());
			procedure.Complete(DateTime.Now);
			Assert.AreEqual(ProcedureStatus.CM, procedure.Status);

			procedure.Cancel();
		}
        public void Test_CanExecute_InProgress()
        {
            Order order = new Order();
            DiscontinueOrderOperation op = new DiscontinueOrderOperation();
            Procedure procedure = new Procedure();
            ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
            order.AddProcedure(procedure);

            step.Start(new Staff());
            Assert.AreEqual(OrderStatus.IP, order.Status);

            Assert.IsTrue(op.CanExecute(order));
        }
Example #33
0
        public void Test_CanExecute_Complete()
        {
            Order order = new Order();
            CancelOrderOperation op = new CancelOrderOperation();
            Procedure procedure = new Procedure();
            ModalityProcedureStep step = new ModalityProcedureStep(procedure, "New modality.", new Healthcare.Modality());
            order.AddProcedure(procedure);

            step.Start(new Staff());
            procedure.Complete(DateTime.Now);
            order.UpdateStatus();
            Assert.AreEqual(OrderStatus.CM, order.Status);

            Assert.IsFalse(op.CanExecute(order));
        }
Example #34
0
		public void Test_IsTerminatedTrue()
		{
			var procedure = new Procedure();
			procedure.Cancel();

			Assert.AreEqual(ProcedureStatus.CA, procedure.Status);
			Assert.IsTrue(procedure.IsTerminated);

			procedure = new Procedure();
			var procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
			procedureStep.Start(new Staff());
			procedure.Complete(Platform.Time);

			Assert.AreEqual(ProcedureStatus.CM, procedure.Status);
			Assert.IsTrue(procedure.IsTerminated);

			procedure = new Procedure();
			procedureStep = new ModalityProcedureStep(procedure, "New Modality", new Modality());
			procedureStep.Start(new Staff());
			procedure.Discontinue();

			Assert.AreEqual(ProcedureStatus.DC, procedure.Status);
			Assert.IsTrue(procedure.IsTerminated);
		}