ShouldEqualJson comparing order misbehaving in lists

Which version of Kotest are you using 4.6.0

Hello,

I’m using shouldEqualJson https://kotest.io/docs/assertions/json-matchers.html#shouldequaljson and standing to the docs, if I set CompareOrder.Lenient, in theory the order shouldn’t matter. As you can see in the following example, I’ve two lists with the same elements, but in different order:

import io.kotest.assertions.json.CompareMode
import io.kotest.assertions.json.CompareOrder
import io.kotest.assertions.json.shouldEqualJson
import org.junit.jupiter.api.Test

class SomeSillyTest {
    @Test
    fun `some silly test`() {
        val currentOne = """
            {
                "some": "thing",
                "listOfStuff": ["a2", "a1"],
                "someList": [
                    {"type": "SOME_TYPE_2"},
                    {"type": "SOME_TYPE_1"}
                ]
            }
        """.trimIndent()
        val expected = """
            {
                "some": "thing",
                "listOfStuff": ["a1", "a2"],
                "someList": [
                    {"type": "SOME_TYPE_1"},
                    {"type": "SOME_TYPE_2"}
                ]
            }
        """.trimIndent()

        currentOne.shouldEqualJson(expected, mode = CompareMode.Lenient, order = CompareOrder.Lenient)
    }
}

Result:

java.lang.AssertionError: At 'listOfStuff.[0]' expected 'a1' but was 'a2'

expected:
{
  "some": "thing",
  "listOfStuff": [
    "a1",
    "a2"
  ],
  "someList": [
    {
      "type": "SOME_TYPE_1"
    },
    {
      "type": "SOME_TYPE_2"
    }
  ]
}

actual:
{
  "some": "thing",
  "listOfStuff": [
    "a2",
    "a1"
  ],
  "someList": [
    {
      "type": "SOME_TYPE_2"
    },
    {
      "type": "SOME_TYPE_1"
    }
  ]
}

[sksamuel]

Maybe LenientProperties and LenientAll but yeah great.

[Kantis]

I think lists/arrays are naturally ordered, whereas object keys aren’t. Perhaps the default should remain as-is, e.g. object key order doesn’t matter, while list order does. I think we should opt for a new CompareOrder which could be used to allow arrays to be out-of-order as well, but I don’t think it makes sense to make that the default behaviour.

Something like this sound ok?

enum class CompareOrder {
   /**
    * All object properties and array items must be in same order as expected.
    * 
    * For example, { "x": 14.2, "y": 13.0 }` and `{ "y": 13.0, "x: 14.2 }` will NOT be considered equal.
    */
   Strict,

   /**
    * See [IgnoreProperties]
    */
   @Deprecated(
      replaceWith = ReplaceWith("CompareOrder.IgnoreProperties"),
      message = "Will be renamed to `IgnoreProperties` in 5.0"
   )
   Lenient,

   /**
    * Ignore the order of object properties, but array order matters. (Default)
    *
    * For example, { "x": 14.2, "y": 13.0 }` and `{ "y": 13.0, "x: 14.2 }` would also be considered equal,
    * since they have the same properties and values.
    * However, `[1, 2]` and `[2, 1]` would NOT be considered equal
    */
   IgnoreProperties,

   /**
    * Ignore the order of object properties and arrays.
    *
    * For example, `[1, 2]` and `[2, 1]` will be considered equal, since they contain the same items.
    * `{ "x": 14.2, "y": 13.0 }` and `{ "y": 13.0, "x: 14.2 }` would also be considered equal, since they have the
    * same properties and values.
    */
   IgnoreAll,
}