public void SuccessfulOpRes_ImplicitCastToBool_True()
        {
            //Arrange
            var opRes = new NamedOperationResultOf <int>(success: true, value: 10);

            //Act
            bool success = opRes;

            //Assert
            Assert.IsTrue(success);
        }
 private static void AssertValuesMatchExpected <TValue>(
     NamedOperationResultOf <TValue> opRes,
     bool expectedSuccessIndication,
     string expectedErrorMessage,
     TValue expectedValue,
     [CallerMemberName] string expectedOpName = null)
 {
     Assert.AreEqual(expectedValue, opRes.Value, $"Expected {nameof(opRes.Value)} '{opRes.Value}' to match '{expectedValue}'");
     Assert.AreEqual(expectedSuccessIndication, opRes.Success, $"Expected {nameof(opRes.Success)} '{opRes.Success}' to match '{expectedSuccessIndication}'");
     Assert.AreEqual(expectedErrorMessage, opRes.ErrorMessage, $"Expected {nameof(opRes.ErrorMessage)} '{opRes.ErrorMessage}' to match '{expectedErrorMessage}'");
     Assert.AreEqual(expectedOpName, opRes.OperationName);
 }
        public void SuccessfulOpRes_ImplicitOperationResult_PropertiesMatch()
        {
            //Arrange
            var opResWithValue = new NamedOperationResultOf <int>(success: true, value: 10);

            //Act
            OperationResult opRes = opResWithValue;

            //Assert
            Assert.AreEqual(opResWithValue.Success, opRes.Success);
            Assert.AreEqual(opResWithValue.ErrorMessage, opRes.ErrorMessage);
        }
 private static void AssertAreEqual <T>(
     NamedOperationResultOf <T> opRes,
     bool expectedSuccessIndication,
     T expectedValue,
     bool actualSuccessIndication,
     T actualValue,
     OperationResult actualOpRes)
 {
     Assert.AreEqual(expectedSuccessIndication, actualSuccessIndication);
     Assert.AreEqual(expectedValue, actualValue);
     Assert.AreEqual(opRes.Success, actualOpRes.Success);
     Assert.AreEqual(opRes.ErrorMessage, actualOpRes.ErrorMessage);
 }
        public void CtorWithExceptionNoErrorMessage_FailedOpResWithMatchingErrorMessage()
        {
            //Arrange
            var exception = new Exception();

            //Act
            var opRes = new NamedOperationResultOf <int>(exception);

            //Assert
            AssertValuesMatchExpected(opRes,
                                      expectedSuccessIndication: false,
                                      expectedErrorMessage: exception.Message,
                                      expectedValue: default);
        }
        public void CtorWithExceptionWithErrorMessage_FailedOpResWithMatchingErrorMessage()
        {
            //Arrange
            const string errorMessage = "Some error message";
            var          exception    = new Exception(errorMessage);

            //Act
            var opRes = new NamedOperationResultOf <int>(exception);

            //Assert
            AssertValuesMatchExpected(opRes,
                                      false,
                                      errorMessage,
                                      default);
        }
        public void CtorWithExceptionInnerExceptionNoErrorMessage_FailedOpResWithMatchingErrorMessage()
        {
            //Arrange
            var exception = new Exception(null, innerException: new Exception());

            //Act
            var opRes = new NamedOperationResultOf <int>(exception);

            //Assert
            AssertValuesMatchExpected(opRes,
                                      expectedSuccessIndication: false,
                                      // ReSharper disable once PossibleNullReferenceException
                                      expectedErrorMessage: exception.InnerException.Message,
                                      expectedValue: default);
        }
        public void RefTypeValueTypeUseExceptionCtor_FailedOperationResultWithMatchingMessageCreated()
        {
            //Arrange
            const bool   expectedSuccessIndication = false;
            const string expectedErrorMessage      = "Some error message";
            const string expectedValue             = default;

            //Act
            var opRes = new NamedOperationResultOf <string>(
                new Exception(expectedErrorMessage));

            //Assert
            AssertValuesMatchExpected(opRes,
                                      expectedSuccessIndication,
                                      expectedErrorMessage,
                                      expectedValue);
        }
        public void RefTypeUseFullCtor_MatchingValuesOperationResultCreated()
        {
            //Arrange
            const bool   expectedSuccessIndication = false;
            const string expectedErrorMessage      = "Some error message";
            const string expectedValue             = "2";

            //Act
            var opRes = new NamedOperationResultOf <string>(
                expectedSuccessIndication,
                expectedValue,
                expectedErrorMessage);

            //Assert
            AssertValuesMatchExpected(opRes,
                                      expectedSuccessIndication,
                                      expectedErrorMessage,
                                      expectedValue);
        }
        public void SuccessfulValueTypeOpRes_ImplicitCast_MatchingExpected()
        {
            //Arrange
            const bool   expectedSuccessIndication = true;
            const string expectedErrorMessage      = null;
            const int    expectedValue             = 2;
            var          opRes = new NamedOperationResultOf <int>(
                expectedSuccessIndication,
                expectedValue,
                errorMessage: expectedErrorMessage);

            //Act
            bool            actualSuccessIndication = opRes;
            int             actualValue             = opRes.Value;
            OperationResult opResNoValue            = opRes;

            //Assert
            AssertAreEqual(opRes,
                           expectedSuccessIndication,
                           expectedValue,
                           actualSuccessIndication,
                           actualValue,
                           opResNoValue);
        }
        public void FailedRefTypeOpRes_ImplicitCast_MatchingExpected()
        {
            //Arrange
            const bool   expectedSuccessIndication = false;
            const string expectedErrorMessage      = "Some error message";
            const string expectedValue             = default;
            var          opRes = new NamedOperationResultOf <string>(
                expectedSuccessIndication,
                expectedValue,
                expectedErrorMessage);

            //Act
            bool            actualSuccessIndication = opRes;
            string          actualValue             = opRes.Value;
            OperationResult opResNoValue            = opRes;

            //Assert
            AssertAreEqual(opRes,
                           expectedSuccessIndication,
                           expectedValue,
                           actualSuccessIndication,
                           actualValue,
                           opResNoValue);
        }