public void SetPropertyValueAfterConfirmation_ConfirmationRequiredAndGivenExceptionInSetValue_ExceptionBubbled()
        {
            // Setup
            DialogBoxHandler = (name, wnd) =>
            {
                var tester = new MessageBoxTester(wnd);
                tester.ClickOk();
            };

            var testFailureMechanism = new TestCalculatableFailureMechanism(
                new[]
            {
                CalculationTestDataFactory.CreateCalculationWithOutput()
            });

            var changeHandler     = new FailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism>();
            var expectedException = new Exception();

            // Call
            void Call() =>
            changeHandler.SetPropertyValueAfterConfirmation(testFailureMechanism, 3, (f, v) =>
            {
                throw expectedException;
            });

            // Assert
            var exception = Assert.Throws <Exception>(Call);

            Assert.AreSame(expectedException, exception);
        }
        public void SetPropertyValueAfterConfirmation_ConfirmationRequiredButNotGiven_SetValueNotCalledNoAffectedObjectsReturned()
        {
            // Setup
            DialogBoxHandler = (name, wnd) =>
            {
                var tester = new MessageBoxTester(wnd);
                tester.ClickCancel();
            };

            ICalculation calculationWithOutput    = CalculationTestDataFactory.CreateCalculationWithOutput();
            ICalculation calculationWithoutOutput = CalculationTestDataFactory.CreateCalculationWithoutOutput();

            var testFailureMechanism = new TestCalculatableFailureMechanism(
                new[]
            {
                calculationWithOutput,
                calculationWithoutOutput
            });
            var propertySet = 0;

            var changeHandler = new FailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism>();

            // Call
            IEnumerable <IObservable> affectedObjects = changeHandler.SetPropertyValueAfterConfirmation(
                testFailureMechanism,
                3,
                (f, v) => propertySet++);

            // Assert
            Assert.AreEqual(0, propertySet);
            CollectionAssert.IsEmpty(affectedObjects);
            Assert.IsTrue(calculationWithOutput.HasOutput);
        }
        public void Constructor_ExpectedValues()
        {
            // Call
            var changeHandler = new FailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism>();

            // Assert
            Assert.IsInstanceOf <IFailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism> >(changeHandler);
        }
        public void SetPropertyValueAfterConfirmation_IfConfirmationRequiredThenGiven_SetValueCalledAffectedObjectsReturned(ChangePropertyTestCase testCase)
        {
            // Setup
            bool dialogBoxWillBeShown = testCase.ExpectedAffectedCalculations.Any();

            var title   = "";
            var message = "";

            if (dialogBoxWillBeShown)
            {
                DialogBoxHandler = (name, wnd) =>
                {
                    var tester = new MessageBoxTester(wnd);
                    title   = tester.Title;
                    message = tester.Text;

                    tester.ClickOk();
                };
            }

            var testFailureMechanism = new TestCalculatableFailureMechanism(testCase.Calculations);
            var propertySet          = 0;

            var changeHandler = new FailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism>();

            // Precondition
            Assert.IsTrue(testCase.ExpectedAffectedCalculations.All(c => c.HasOutput));

            // Call
            IEnumerable <IObservable> affectedObjects = changeHandler.SetPropertyValueAfterConfirmation(
                testFailureMechanism,
                3,
                (f, v) => propertySet++);

            // Assert
            if (dialogBoxWillBeShown)
            {
                Assert.AreEqual("Bevestigen", title);
                string expectedMessage = "Als u deze parameter wijzigt, zal de uitvoer van alle berekeningen in dit faalmechanisme verwijderd worden."
                                         + Environment.NewLine + Environment.NewLine +
                                         "Weet u zeker dat u wilt doorgaan?";
                Assert.AreEqual(expectedMessage, message);
            }

            Assert.AreEqual(1, propertySet);
            var expectedAffectedObjects = new List <IObservable>(testCase.ExpectedAffectedCalculations)
            {
                testFailureMechanism
            };

            CollectionAssert.AreEqual(expectedAffectedObjects, affectedObjects);
            Assert.IsTrue(testCase.Calculations.All(c => !c.HasOutput));
        }
        public void SetPropertyValueAfterConfirmation_WithoutSetProperty_ThrowsArgumentNullException()
        {
            // Setup
            var changeHandler = new FailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism>();

            // Call
            void Call() => changeHandler.SetPropertyValueAfterConfirmation(new TestCalculatableFailureMechanism(), 3, null);

            // Assert
            string paramName = Assert.Throws <ArgumentNullException>(Call).ParamName;

            Assert.AreEqual("setValue", paramName);
        }
        public void SetPropertyValueAfterConfirmation_ConfirmationNotRequiredExceptionInSetValue_ExceptionBubbled()
        {
            // Setup
            var testFailureMechanism = new TestCalculatableFailureMechanism();
            var changeHandler        = new FailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism>();
            var expectedException    = new Exception();

            // Call
            void Call() =>
            changeHandler.SetPropertyValueAfterConfirmation(testFailureMechanism, 3, (f, v) =>
            {
                throw expectedException;
            });

            // Assert
            var exception = Assert.Throws <Exception>(Call);

            Assert.AreSame(expectedException, exception);
        }