Duplicate patterns included in suggestions with nested maps/structs

Question

Duplicate patterns included in suggestions with nested maps/structs

Closed this issue 8 months ago · 5 comments

Have a look at these 2 screenshots.

First: notice the huge number of options on the bottom...
Second: notice that there is no difference in the pattern mneme suggests, although I did press j between the 2 screenshots.

I'll see if I can come up with a smaller reproduction 😄

Answer 1 · 2023-11-02T15:46:22.000Z

a somewhat smaller reproduction:

    test "t2" do
      x = %{
        blocks: [
          %{
            block: %{
              id: "path-1",
              title: "First Subsection"
            },
            id: %{block: 0, page: 0}
          },
          %{
            block: %{markdown: "M1"},
            id: %{block: 1, page: 0}
          }
        ]
      }

      auto_assert %{
                    blocks: [
                      %{
                        block: %{id: "path-1"},
                        id: %{block: 0, page: 0}
                      },
                      %{block: %{markdown: "M1"}, id: %{block: 1, page: 2}}
                    ]
                  } <- x
    end

and screenshot:

Edit: removed the structs, so you can copy paste it yourself.

Answer 2 · 2023-11-02T16:20:57.000Z

There are definitely some duplicates in there -- I'll look into that for sure.

As for the sheer number of suggestions: Even without the duplicates, I expect there will still be a lot of suggestions for that value. It's a sort of "perfect storm" that I need to think a bit more about how to handle. Consider this basic case:

auto_assert %{bar: "bar"} <- %{foo: :foo, bar: :bar, baz: :baz}

This is going to generate 3 suggestions:

# only update the key that was previously present
auto_assert %{bar: :bar} <- %{foo: :foo, bar: :bar, baz: :baz}

# assert it's an empty map
auto_assert %{} <- %{foo: :foo, bar: :bar, baz: :baz}

# assert all keys
auto_assert %{foo: :foo, bar: :bar, baz: :baz} <- %{foo: :foo, bar: :bar, baz: :baz}

The problem, then, is that it will do that recursively on nested fields. So if you map contains maps (or your struct contains structs), you'll potentially get all of those recursively, which leads to some exponential explosion.

I'd be really interested in the before & after. Knowing what pattern you ultimately accepted might help me improve the suggestions going forward.

Answer 3 · 2023-11-02T16:30:35.000Z

Personally I don't need perfect suggestions, because I use the suggestion that captures the necessary things and then clean up manually.
So I try to select the suggestion that shows at least the data that I need but nothing more.

Most tests are simpler in output than this one. But I love how simple mneme makes it to rapidly iterate over items that are still in progress.

I'll think a bit more about this. But I'm not at my pc anymore, so that's something for tomorrow

Answer 4 · 2023-11-03T09:19:59.000Z

Here is an example of how I often use mneme:

let's say I have this code

auto_assert %{a: %{x: 1}}  <- %{a: %{x: 1, y: 2}}

and now the output of the code changes so that extra keys are added:

auto_assert %{a: %{x: 1}}  <- %{a: %{x: 1, y: 2}, b: %{z: 0}, c: [0,1]}

Because I already cleaned up the input on the left side of the <- I don't want to remove the full assertion, instead I'm often going to change a single value like this:

auto_assert %{a: %{x: 2}}  <- %{a: %{x: 1, y: 2}, b: %{z: 0}, c: [0,1]}

so that mneme gives me new suggestions

mix test --only only
Excluding tags: [:test]
Including tags: [:only]

.
[1] Update · test view/1 1 (DomainModelling.Course.ViewTest)
test/domain_modelling/course/view_test.exs:13

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  -  auto_assert %{a: %{x: 2}} <- %{a: %{x: 1, y: 2}, b: %{z: 0}, c: [0, 1]}
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  +  auto_assert %{a: %{x: 1}} <- %{a: %{x: 1, y: 2}, b: %{z: 0}, c: [0, 1]}
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Value has changed! Update pattern?
> k
y yes  n no  s skip  ❮ j ○○●○○○○ k ❯


[1] Update · test view/1 1 (DomainModelling.Course.ViewTest)
test/domain_modelling/course/view_test.exs:13

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  -  auto_assert %{a: %{x: 2}} <- %{a: %{x: 1, y: 2}, b: %{z: 0}, c: [0, 1]}
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  +  auto_assert %{a: %{x: 1, y: 2}} <- %{a: %{x: 1, y: 2}, b: %{z: 0}, c: [0, 1]}
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Value has changed! Update pattern?
> k
y yes  n no  s skip  ❮ j ○○○●○○○ k ❯


[1] Update · test view/1 1 (DomainModelling.Course.ViewTest)
test/domain_modelling/course/view_test.exs:13

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  -  auto_assert %{a: %{x: 2}} <- %{a: %{x: 1, y: 2}, b: %{z: 0}, c: [0, 1]}
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  +  auto_assert %{a: %{}, b: %{}, c: [0, 1]} <- %{a: %{x: 1, y: 2}, b: %{z: 0}, c: [0, 1]}
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Value has changed! Update pattern?
> k
y yes  n no  s skip  ❮ j ○○○○●○○ k ❯


[1] Update · test view/1 1 (DomainModelling.Course.ViewTest)
test/domain_modelling/course/view_test.exs:13

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  -  auto_assert %{a: %{x: 2}} <- %{a: %{x: 1, y: 2}, b: %{z: 0}, c: [0, 1]}
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  +  auto_assert %{a: %{x: 1}, b: %{z: 0}, c: [0, 1]} <- %{a: %{x: 1, y: 2}, b: %{z: 0}, c: [0, 1]}
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Value has changed! Update pattern?
> y
y yes  n no  s skip  ❮ j ○○○○○●○ k ❯
...

[Mneme] 1 updated

Finished in 5.1 seconds (5.1s async, 0.00s sync)
89 tests, 0 failures, 85 excluded

Randomized with seed 993189

The last one is the one I need. It didn't change the structure of what was already there, but added the 2 new keys fully.
The first suggestion of mneme is good, but I don't think that in the above scenario I would ever want to chose the 2nd or 3rd.

I'm not sure there is a good solution to this though, maybe adding some other keymaps to jump to specific suggestions directly, but that makes things more complex...

Answer 5 · 2023-11-05T13:35:38.000Z

Thank you for this example!

I don't think we can confidently discard the 2nd suggestion -- in this case you don't want it because we know that :y wasn't just added, but Mneme doesn't know that because it only knows the last pattern, not the last value, so it's very possible that :y was just added.

I agree that the 3rd suggestion is probably not very valuable. I'm actually somewhat questioning the utility of empty maps as patterns. I think that empty structs are valuable because you're still asserting something, but the utility of asserting an empty map is pretty marginal and I personally rarely use it, if ever. I'm going to post a proposal to get rid of them, I think, and get some feedback from other folks.

If we do away with empty map patterns as suggestions, the inferred suggestion would be a lot closer to your desired outcome.