A composite validator pattern

Have you ever encountered something like this?
(Note: #r denotes a collapsed region of code)

public class MyBulkyClassThatDoesALot
{
    #r Private fields
    #r Constructor
    #r Another constructor
    #r Public properties
    #r Public methods
    #r Private methods

    #region Validation

    // meanwhile, somewhere on line 20485
    public ValidationResult Validate()
    {
        ValidationResult result;
        CheckThatSomethingHolds(result);
        CheckThatSomethingElseHolds(result);

        if (this.somesituation)
        {
            CheckSituationDependentCondition(result);
            CheckSituationDependentOtherCondition(result);
        }

        ...
        // Somewhere on line 20585
        CheckLastThing(result);
        return result;
    }

    private void CheckThatSomethingHolds(ValidationResult result)
    {
        if (this.somecondition)
        {
            result.AddError(new ValidationError("Condition X failed"));
        }
    }

    private void CheckThatSomethingElseHolds(ValidationResult result)
    {
        if (this.somecondition)
        {
            result.AddError(new ValidationError("Condition Y failed"));
        }
    }

    private void CheckSituationDependentCondition(result)
    {
        if (this.somecondition)
        {
            result.AddError(new ValidationError("Condition SituationDependent1 failed"));
        }
    }

    // Are you tired of scrolling yet? Good, because this is how whomever reads this code shall feel in real life ;)

    private void CheckSituationDependentOtherCondition(result) { ... snip }

    // A sigh of relief when you reach the last one
    private void CheckLastThing(ValidationResult result)
    {
        if (this.somecondition)
        {
            result.AddError(new ValidationError("Condition Z failed"));
        }
    }

    #endregion Validation

    // And then, of course, there is a lot of code after this. If you're unlucky, there wasn't even a #region around all the Validation methods and you have to hunt them down one by one because they are scattered through the code.
}

Don’t worry, you’re not the first one to end up with this. Often, it started as a single validation rule that was just implemented directly in the class to be validated. However, there are some things to look out for.

Test test test 

A fellow software engineer today: “I don’t know what the TreeTestHelperTest *falters*… tests.” 

If

The difference between an implication and a bi-implication is this: I am a crazy cat lady. I just don’t have all the cats yet XD

Unit testing 001

“Man, I just love unit tests, I’ve just been able to make a bunch of changes to the way something works, and then was able to confirm I hadn’t broken anything by running the test over it again…” — http://stackoverflow.com/a/67500

The benefits of unit testing are well known, as are the many reasons that are offered when asked “Why don’t you do it?”. The arguments I hear over and over are:

  • “It takes too much time.”
  • “Our code isn’t suitable for unit testing.”

I’ve discussed unit testing with many people in the past years and at some point, I discovered one of the main reasons behind the arguments that were actually offered. We human beings find it much easier to say “It’s not possible”, “It’s too expensive”, “I don’t want to” or “I won’t start doing this until I’ve seen it work” (this one I encounter surprisingly often and makes me smile nowadays) than to admit:

  • “I don’t know how”