public void ValidationException()
        {
            TargetClassDefinition definition = DefinitionObjectMother.BuildUnvalidatedDefinition(
                typeof(ClassOverridingSingleMixinMethod), typeof(AbstractMixinWithoutBase));

            var log     = new DefaultValidationLog();
            var visitor = new ValidatingVisitor(log);

            new DefaultMethodRules().Install(visitor);
            definition.Accept(visitor);

            var validationLogData = log.GetData();
            var exception         = new ValidationException(validationLogData);

            Assert.That(
                exception.Message,
                Is.EqualTo(
                    "Some parts of the mixin configuration could not be validated."
                    + Environment.NewLine
                    + "MethodDefinition 'Remotion.Mixins.UnitTests.Core.Validation.ValidationTestDomain.AbstractMixinWithoutBase.AbstractMethod', 6 rules "
                    + "executed"
                    + Environment.NewLine
                    + "Context: Remotion.Mixins.UnitTests.Core.Validation.ValidationTestDomain.AbstractMixinWithoutBase -> "
                    + "Remotion.Mixins.UnitTests.Core.TestDomain.ClassOverridingSingleMixinMethod"
                    + Environment.NewLine
                    + "  failures - 1"
                    + Environment.NewLine
                    + "    A target class overrides a method from one of its mixins, but the mixin is not derived from one of the Mixin<...> base classes. "
                    + "(Remotion.Mixins.Validation.Rules.DefaultMethodRules.OverridingMixinMethodsOnlyPossibleWhenMixinDerivedFromMixinBase)"
                    + Environment.NewLine
                    ));
        }
        public void GetValidationLogFromValidationException()
        {
            var validationLogData   = new DefaultValidationLog();
            var validationException = new ValidationException(validationLogData);

            var reflectedValidationLog = _remotionReflector.GetValidationLogFromValidationException(validationException);
            var result = reflectedValidationLog.To <ValidationLogNullObject> ();

            Assert.That(result, Is.Not.Null);
        }
        public void IsValidationException()
        {
            var validationLogData   = new DefaultValidationLog();
            var validationException = new ValidationException(validationLogData);

            var outputTrue  = _remotionReflector.IsValidationException(validationException);
            var outputFalse = _remotionReflector.IsValidationException(new Exception());

            Assert.That(outputTrue, Is.True);
            Assert.That(outputFalse, Is.False);
        }
        public void Serialization()
        {
            var log  = new DefaultValidationLog();
            var rule = new DelegateValidationRule <TargetClassDefinition> (DummyRule);

            var definition = DefinitionObjectMother.CreateTargetClassDefinition(typeof(object));

            log.ValidationStartsFor(definition);
            log.Succeed(rule);
            log.ValidationEndsFor(definition);

            var exception = new ValidationException(log.GetData());

            var deserializedException = Serializer.SerializeAndDeserialize(exception);

            Assert.That(deserializedException.Message, Is.EqualTo(exception.Message));
            Assert.That(deserializedException.ValidationLogData, Is.Not.Null);
        }
        public void Ctor_CopiesPropertiesFromValidationLogData()
        {
            var log        = new DefaultValidationLog();
            var rule       = new DelegateValidationRule <TargetClassDefinition> (DummyRule);
            var definition = DefinitionObjectMother.CreateTargetClassDefinition(typeof(object));

            log.ValidationStartsFor(definition);
            log.Succeed(rule);
            log.ValidationEndsFor(definition);

            var expected = log.GetData();
            var actual   = expected.MakeSerializable();

            Assert.That(actual.NumberOfFailures, Is.EqualTo(expected.GetNumberOfFailures()));
            Assert.That(actual.NumberOfRulesExecuted, Is.EqualTo(expected.GetNumberOfRulesExecuted()));
            Assert.That(actual.NumberOfSuccesses, Is.EqualTo(expected.GetNumberOfSuccesses()));
            Assert.That(actual.NumberOfUnexpectedExceptions, Is.EqualTo(expected.GetNumberOfUnexpectedExceptions()));
            Assert.That(actual.NumberOfWarnings, Is.EqualTo(expected.GetNumberOfWarnings()));
        }
        public void Serializable()
        {
            var log        = new DefaultValidationLog();
            var rule       = new DelegateValidationRule <TargetClassDefinition> (DummyRule);
            var definition = DefinitionObjectMother.CreateTargetClassDefinition(typeof(object));

            log.ValidationStartsFor(definition);
            log.Succeed(rule);
            log.ValidationEndsFor(definition);

            var serializableValidationLogData = log.GetData().MakeSerializable();

            var deserialized = Serializer.SerializeAndDeserialize(serializableValidationLogData);

            Assert.That(deserialized.NumberOfFailures, Is.EqualTo(serializableValidationLogData.NumberOfFailures));
            Assert.That(deserialized.NumberOfRulesExecuted, Is.EqualTo(serializableValidationLogData.NumberOfRulesExecuted));
            Assert.That(deserialized.NumberOfSuccesses, Is.EqualTo(serializableValidationLogData.NumberOfSuccesses));
            Assert.That(deserialized.NumberOfUnexpectedExceptions, Is.EqualTo(serializableValidationLogData.NumberOfUnexpectedExceptions));
            Assert.That(deserialized.NumberOfWarnings, Is.EqualTo(serializableValidationLogData.NumberOfWarnings));
        }
        public void GetValidationLogFromValidationException()
        {
            var validationLogData = new DefaultValidationLog ();
              var validationException = new ValidationException (validationLogData);

              var reflectedValidationLog = _remotionReflector.GetValidationLogFromValidationException (validationException);
              var result = reflectedValidationLog.To<ValidationLogNullObject> ();
              Assert.That (result, Is.Not.Null);
        }
        public void IsValidationException()
        {
            var validationLogData = new DefaultValidationLog ();
              var validationException = new ValidationException (validationLogData);

              var outputTrue = _remotionReflector.IsValidationException (validationException);
              var outputFalse = _remotionReflector.IsValidationException (new Exception ());

              Assert.That (outputTrue, Is.True);
              Assert.That (outputFalse, Is.False);
        }
        public void Merge()
        {
            IValidationLog sourceLog = new DefaultValidationLog();
            var            exception = new Exception();

            TargetClassDefinition bt1 = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType1));
            TargetClassDefinition bt2 = DefinitionObjectMother.GetActiveTargetClassDefinition_Force(typeof(BaseType2));
            TargetClassDefinition bt3 = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType3));
            TargetClassDefinition bt4 = DefinitionObjectMother.GetActiveTargetClassDefinition_Force(typeof(BaseType4));

            sourceLog.ValidationStartsFor(bt1);
            sourceLog.Succeed(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "Success", "Success"));
            sourceLog.Warn(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "Warn", "Warn"));
            sourceLog.Fail(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "Fail", "Fail"));
            sourceLog.UnexpectedException(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "Except", "Except"), exception);
            sourceLog.ValidationEndsFor(bt1);

            sourceLog.ValidationStartsFor(bt4);
            sourceLog.Succeed(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "Success2", "Success2"));
            sourceLog.Warn(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "Warn2", "Warn2"));
            sourceLog.Fail(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "Fail2", "Fail2"));
            sourceLog.UnexpectedException(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "Except2", "Except2"), exception);
            sourceLog.ValidationEndsFor(bt4);

            IValidationLog resultLog = new DefaultValidationLog();

            resultLog.ValidationStartsFor(bt2);
            resultLog.Succeed(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "0", "0"));
            resultLog.Warn(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "1", "1"));
            resultLog.Fail(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "2", "2"));
            resultLog.UnexpectedException(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "3", "3"), exception);
            resultLog.ValidationEndsFor(bt2);

            resultLog.ValidationStartsFor(bt1);
            resultLog.Succeed(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "4", "4"));
            resultLog.Warn(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "5", "5"));
            resultLog.Fail(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "6", "6"));
            resultLog.UnexpectedException(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "7", "7"), exception);
            resultLog.ValidationEndsFor(bt1);

            resultLog.ValidationStartsFor(bt3);
            resultLog.Succeed(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "8", "8"));
            resultLog.Warn(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "9", "9"));
            resultLog.Fail(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "10", "10"));
            resultLog.UnexpectedException(new DelegateValidationRule <TargetClassDefinition> (delegate { }, "11", "11"), exception);
            resultLog.ValidationEndsFor(bt3);

            var logData = resultLog.GetData();

            logData.Add(sourceLog.GetData());
            Assert.That(logData.GetNumberOfSuccesses(), Is.EqualTo(5));
            Assert.That(logData.GetNumberOfWarnings(), Is.EqualTo(5));
            Assert.That(logData.GetNumberOfFailures(), Is.EqualTo(5));
            Assert.That(logData.GetNumberOfUnexpectedExceptions(), Is.EqualTo(5));

            var results = new List <ValidationResult> (logData.GetResults());

            Assert.That(results.Count, Is.EqualTo(4));

            Assert.That(results[0].ValidatedDefinition, Is.EqualTo(bt2));
            Assert.That(results[0].Successes.Count, Is.EqualTo(1));
            Assert.That(results[0].Failures.Count, Is.EqualTo(1));
            Assert.That(results[0].Warnings.Count, Is.EqualTo(1));
            Assert.That(results[0].Exceptions.Count, Is.EqualTo(1));

            Assert.That(results[1].ValidatedDefinition, Is.EqualTo(bt1));

            Assert.That(results[1].Successes.Count, Is.EqualTo(2));
            Assert.That(results[1].Successes[0].Message, Is.EqualTo("4"));
            Assert.That(results[1].Successes[1].Message, Is.EqualTo("Success"));

            Assert.That(results[1].Warnings.Count, Is.EqualTo(2));
            Assert.That(results[1].Warnings[0].Message, Is.EqualTo("5"));
            Assert.That(results[1].Warnings[1].Message, Is.EqualTo("Warn"));

            Assert.That(results[1].Failures.Count, Is.EqualTo(2));
            Assert.That(results[1].Failures[0].Message, Is.EqualTo("6"));
            Assert.That(results[1].Failures[1].Message, Is.EqualTo("Fail"));

            Assert.That(results[1].Exceptions.Count, Is.EqualTo(2));
            Assert.That(results[1].Exceptions[0].Exception, Is.EqualTo(exception));
            Assert.That(results[1].Exceptions[1].Exception, Is.EqualTo(exception));

            Assert.That(results[2].ValidatedDefinition, Is.EqualTo(bt3));
            Assert.That(results[2].Successes.Count, Is.EqualTo(1));
            Assert.That(results[2].Failures.Count, Is.EqualTo(1));
            Assert.That(results[2].Warnings.Count, Is.EqualTo(1));
            Assert.That(results[2].Exceptions.Count, Is.EqualTo(1));

            Assert.That(results[3].ValidatedDefinition, Is.EqualTo(bt4));

            Assert.That(results[3].Successes.Count, Is.EqualTo(1));
            Assert.That(results[3].Successes[0].Message, Is.EqualTo("Success2"));

            Assert.That(results[3].Warnings.Count, Is.EqualTo(1));
            Assert.That(results[3].Warnings[0].Message, Is.EqualTo("Warn2"));

            Assert.That(results[3].Failures.Count, Is.EqualTo(1));
            Assert.That(results[3].Failures[0].Message, Is.EqualTo("Fail2"));

            Assert.That(results[3].Exceptions.Count, Is.EqualTo(1));
            Assert.That(results[3].Exceptions[0].Exception, Is.EqualTo(exception));
        }