test: add browser test for flyout copy shadow ID uniqueness

Adds a behavior test that exercises the actual flyout createBlock path
(using CheckableContinuousFlyout) and verifies that two copies from
the same flyout template get unique shadow IDs, even when the first
copy's shadow was disposed (obscured by a reporter).

This test reliably fails without the stripIds call in
CheckableContinuousFlyout.serializeBlock (added in PR #3560).

Author: cwillisf

tests/browser/block_duplicate_shadow.test.ts

@@ -3,27 +3,27 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import * as Blockly from 'blockly/core'
-import { afterEach, assert, beforeEach, describe, expect, it } from 'vitest'
+import { afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, it } from 'vitest'
+import { CheckableContinuousFlyout } from '../../src/checkable_continuous_flyout'
+import { registerRecyclableBlockFlyoutInflater } from '../../src/recyclable_block_flyout_inflater'
 import { registerScratchBlockPaster } from '../../src/scratch_block_paster'
 
-// Browser test: duplicating a block with an obscured shadow must produce a
-// copy with unique shadow IDs. Without the stripIds fix in
-// ScratchBlockPaster.paste, the copy reuses the original's shadow IDs,
-// causing the VM to think both blocks share the same shadow. Deleting one
-// then destroys the other's shadow (forum topic 878291).
+// Browser tests for the shared-shadow-ID bug (forum topic 878291).
+// Both the duplicate/paste path and the flyout copy path must produce
+// blocks with unique shadow IDs. Without stripIds, disposed shadows
+// from the original reuse their IDs in the copy, causing the VM to
+// think both blocks share the same shadow.
 
 const BLOCK_TYPES = ['test_value_block', 'test_text_shadow', 'test_reporter']
 
-let container: HTMLElement
-let workspace: Blockly.WorkspaceSvg
+let container: HTMLElement | undefined
+let workspace: Blockly.WorkspaceSvg | undefined
 
 beforeEach(() => {
   container = document.createElement('div')
   container.style.width = '800px'
   container.style.height = '600px'
   document.body.appendChild(container)
-  workspace = Blockly.inject(container, {})
-  registerScratchBlockPaster()
 
   Blockly.defineBlocksWithJsonArray([
     {
@@ -47,36 +47,64 @@ beforeEach(() => {
   ])
 })
 
+// Save the default Blockly implementations so we can restore them after
+// all tests, preventing cross-suite leakage of Scratch-specific overrides.
+const DefaultInflater = Blockly.registry.getClass(Blockly.registry.Type.FLYOUT_INFLATER, 'block')
+
+beforeAll(() => {
+  registerScratchBlockPaster()
+  registerRecyclableBlockFlyoutInflater()
+})
+
+afterAll(() => {
+  // Restore the default block paster
+  Blockly.clipboard.registry.unregister(Blockly.clipboard.BlockPaster.TYPE)
+  Blockly.clipboard.registry.register(Blockly.clipboard.BlockPaster.TYPE, new Blockly.clipboard.BlockPaster())
+  // Restore the default flyout inflater
+  if (DefaultInflater) {
+    Blockly.registry.unregister(Blockly.registry.Type.FLYOUT_INFLATER, 'block')
+    Blockly.registry.register(Blockly.registry.Type.FLYOUT_INFLATER, 'block', DefaultInflater)
+  }
+})
+
 afterEach(() => {
-  workspace.dispose()
-  container.remove()
+  workspace?.dispose()
+  container?.remove()
   for (const t of BLOCK_TYPES) {
     delete Blockly.Blocks[t]
   }
 })
 
 describe('duplicate block shadow IDs (forum topic 878291)', () => {
   it('duplicated block gets unique shadow IDs, not shared with original', () => {
+    assert(container, 'Expected container from beforeEach')
+    workspace = Blockly.inject(container, {})
+
     // Create the original block with a shadow on VALUE
+    let original: Blockly.BlockSvg
+    let reporter: Blockly.BlockSvg
     Blockly.Events.disable()
-    const original = Blockly.serialization.blocks.append(
-      {
-        type: 'test_value_block',
-        inputs: {
-          VALUE: {
-            shadow: {
-              type: 'test_text_shadow',
-              fields: { TEXT: '0' },
+    try {
+      original = Blockly.serialization.blocks.append(
+        {
+          type: 'test_value_block',
+          inputs: {
+            VALUE: {
+              shadow: {
+                type: 'test_text_shadow',
+                fields: { TEXT: '0' },
+              },
             },
           },
         },
-      },
-      workspace,
-    ) as Blockly.BlockSvg
+        workspace,
+      ) as Blockly.BlockSvg
 
-    // Connect a reporter to obscure the shadow
-    const reporter = workspace.newBlock('test_reporter')
-    Blockly.Events.enable()
+      // Connect a reporter to obscure the shadow
+      reporter = workspace.newBlock('test_reporter')
+    } finally {
+      Blockly.Events.enable()
+    }
 
     const conn = original.getInput('VALUE')?.connection
     assert(conn, 'Expected VALUE connection')
@@ -113,4 +141,71 @@ describe('duplicate block shadow IDs (forum topic 878291)', () => {
     expect(respawned.isShadow()).toBe(true)
     expect(respawned.type).toBe('test_text_shadow')
   })
+
+  it('two flyout copies get unique shadow IDs when first copy shadow is obscured', () => {
+    assert(container, 'Expected container from beforeEach')
+    // Inject with CheckableContinuousFlyout (which has the stripIds fix)
+    // and a toolbox that includes a block with a shadow input.
+    workspace = Blockly.inject(container, {
+      toolbox: {
+        kind: 'flyoutToolbox',
+        contents: [
+          {
+            kind: 'block',
+            type: 'test_value_block',
+            inputs: {
+              VALUE: {
+                shadow: {
+                  type: 'test_text_shadow',
+                  fields: { TEXT: '0' },
+                },
+              },
+            },
+          },
+        ],
+      },
+      plugins: {
+        flyoutsVerticalToolbox: CheckableContinuousFlyout,
+      },
+    })
+
+    const flyout = workspace.getFlyout()
+    assert(flyout, 'Expected workspace to have a flyout')
+
+    // Find the template block in the flyout
+    const flyoutBlocks = flyout.getWorkspace().getAllBlocks(false)
+    const template = flyoutBlocks.find((b) => b.type === 'test_value_block')
+    assert(template, 'Expected template block in flyout')
+
+    // First copy from flyout
+    const copy1 = flyout.createBlock(template)
+    const conn1 = copy1.getInput('VALUE')?.connection
+    assert(conn1, 'Expected VALUE connection on first copy')
+    const shadow1 = conn1.targetBlock()
+    assert(shadow1, 'Expected shadow on first copy')
+    expect(shadow1.isShadow()).toBe(true)
+    const shadow1Id = shadow1.id
+
+    // Obscure the first copy's shadow by connecting a reporter
+    let reporter: Blockly.BlockSvg
+    Blockly.Events.disable()
+    try {
+      reporter = workspace.newBlock('test_reporter')
+    } finally {
+      Blockly.Events.enable()
+    }
+    const reporterOutput = reporter.outputConnection
+    assert(reporterOutput, 'Expected reporter output connection')
+    conn1.connect(reporterOutput)
+
+    // Second copy from flyout — its shadow must get a different ID
+    const copy2 = flyout.createBlock(template)
+    const conn2 = copy2.getInput('VALUE')?.connection
+    assert(conn2, 'Expected VALUE connection on second copy')
+    const shadow2 = conn2.targetBlock()
+    assert(shadow2, 'Expected shadow on second copy')
+    expect(shadow2.isShadow()).toBe(true)
+
+    expect(shadow2.id).not.toBe(shadow1Id)
+  })
 })