allOf, anyOf etc. does not permit arrays of matchers

[kordzik]

Sometimes it's useful to dynamically generate an array of matchers and pass it to allOf, anyOf etc. Unfortunately those functions only seem to support arguments list OOTB, so they need to be called using

__.allOf.apply(this, mymatchers);

instead, which is not too bad, but it'd be nice if there was a check for when arguments.length === 1 and the only argument is an array, and use the array as input to AllOf (and other aggregate matchers).

[rluba]

Good idea. I always cringe when I have to use the apply pattern for allOf, anyOf or (most commonly) contains. But for the latter, it would create a weird edge case if you want to test if an array contains exactly on element that is also an array:

var nested = [['X', 'Y']];

__.assertThat(nested, __.contains(['X', 'Y'])); // Before implementing your feature
__.assertThat(nested, __.contains([['X', 'Y']]); // Afterwards: Needs extra [] => looks wrong

Not sure what I could do about that. Any suggestions?

[kordzik]

Good point. I guess you could add another restriction that it'd have to be an array of matchers. But at that stage I guess it might be getting to edge-case-y and confusing, so up to you whether you want to include it in the core Hamjest. It's easy enough to customize in the test suite anyway (which I've done already:)

[kordzik]

In case anyone wants to add it too, the snippet below worked for us (don't judge my JS please, I'm a Java dev at heart ;)

    function applyForMatcherArray(original) {
        return function() {
            // check for 1 argument that is an array of matchers
            if (arguments.length == 1 && _.isArray(arguments[0]) && _.every(arguments[0], __.Matcher.isMatcher)) {
                // invoke using it as arguments
                return original.apply(this, arguments[0]);
            } else {
                // just invoke the original
                return original.apply(this, _.toArray(arguments));
            }
        }
    }

and then

_.extend({}, __, {
    allOf: applyForMatcherArray(__.allOf)
    // etc.
}

[rluba]

I'll implement this feature for anyOf / allOf. Above-mentioned edge case does not affect them since they demand matchers as arguments.

But I'm not sure how to implement it for contains without creating weird edge cases or unintuitive matcher code because contains allows matchers and non-matcher values

[kordzik]

Sounds good, thanks!