just and contains checkers have some tricky logic that normalizes the expected and actual arguments. In a specific corner case, when actual is a map and expected is a list of maps, the normalization logic tries to turn expected into a map. This can lead to loss of information due to key merging, and hence incorrect check results.
For example, the following fact erroneously passes:
(fact
{:a 2} => (just [{:a 1} {:a 2}])
; `just` will turn ` [{:a 1} {:a 2}]` into {:a 2} via `(into {} expected)`
Such merging in the context of just can never result in a true result, so my solution is to prevent such normalization, leaving expected as a list, hence causing the check to fail.
The same applies to contains because if actual is a map and expected is a list of maps, any merging means that the actual map can never contain the entries (which will have duplicates) in the expected list.
The last usage of standardized-arguments is for has-prefix, which doesn't have sensible semantics when actual is a map, so we don't need to worry about it.
Fix for https://github.com/marick/Midje/issues/348
justandcontainscheckers have some tricky logic that normalizes theexpectedandactualarguments. In a specific corner case, whenactualis a map andexpectedis a list of maps, the normalization logic tries to turnexpectedinto a map. This can lead to loss of information due to key merging, and hence incorrect check results.For example, the following
facterroneously passes:Such merging in the context of
justcan never result in atrueresult, so my solution is to prevent such normalization, leavingexpectedas a list, hence causing the check to fail.The same applies to
containsbecause ifactualis a map andexpectedis a list of maps, any merging means that theactualmap can never contain the entries (which will have duplicates) in theexpectedlist.The last usage of
standardized-argumentsis forhas-prefix, which doesn't have sensible semantics whenactualis a map, so we don't need to worry about it.