diff --git a/src/extensions/core/widgetFormProof.domWidgets.test.ts b/src/extensions/core/widgetFormProof.domWidgets.test.ts new file mode 100644 index 00000000000..34135815115 --- /dev/null +++ b/src/extensions/core/widgetFormProof.domWidgets.test.ts @@ -0,0 +1,152 @@ +import { fromPartial } from '@total-typescript/shoehorn' +import { assert, describe, expect, it, vi } from 'vitest' + +import { load3dWidgets } from '@/extensions/core/load3d/load3dWidgets' +import { + audioWidgetExtension, + recordAudioExtension +} from '@/extensions/core/uploadAudio' +import { LGraphNode } from '@/lib/litegraph/src/litegraph' +import type { LGraphNodeConstructor } from '@/lib/litegraph/src/litegraph' +import { + coreIsLastWriter, + serializeWithCapture +} from '@/lib/litegraph/src/widgets/__fixtures__/widgetFormProofHarness' +import { proveWidgetForm } from '@/lib/litegraph/src/widgets/widgetFormProof' +import type { WidgetFormProof } from '@/lib/litegraph/src/widgets/widgetFormProof' +import { useImageUploadWidget } from '@/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget' +import type { ComfyApp } from '@/scripts/app' +import '@/scripts/domWidget' + +const noApp = () => fromPartial({}) + +function proveSerialization(node: LGraphNode) { + const captured = serializeWithCapture(node) + return { + values: captured.final.widgets_values, + proof: proveWidgetForm( + captured.widgetsAtCoreSite, + captured.final, + captured.atCoreSite, + { + serializeWidgets: node.serialize_widgets, + replayed: false, + coreIsLastWriter: coreIsLastWriter(node) + } + ) + } +} + +function refusal(reason: NonNullable) { + return { provable: false, refusal: reason, order: null } +} + +function registeredNode(title: string): LGraphNode { + const node = new LGraphNode(title) + node.serialize_widgets = true + return node +} + +describe('case 4 — DOM widgets', () => { + it('proves PREVIEW_3D, whose viewport widget occupies a slot', () => { + const node = registeredNode('Preview3D') + load3dWidgets.PREVIEW_3D(node, 'image', ['PREVIEW_3D', {}], noApp()) + + expect(proveSerialization(node)).toEqual({ + values: [''], + proof: { provable: true, refusal: null, order: ['image'] } + }) + }) + + it('proves LOAD_3D, counting its three unflagged buttons', () => { + const node = registeredNode('Load3D') + node.addWidget('combo', 'model_file', 'a.glb', () => {}, { + values: ['a.glb'] + }) + load3dWidgets.LOAD_3D(node, 'image', ['LOAD_3D', {}], noApp()) + + expect(proveSerialization(node)).toEqual({ + values: ['a.glb', 'upload3dmodel', 'uploadExtraResources', 'clear', ''], + proof: { + provable: true, + refusal: null, + order: [ + 'model_file', + 'upload 3d model', + 'upload extra resources', + 'clear', + 'image' + ] + } + }) + }) + + it('proves IMAGEUPLOAD at two slots, because the upload button is options-bag-flagged', () => { + const node = registeredNode('LoadImage') + node.addWidget('combo', 'image', 'x.png', () => {}, { values: ['x.png'] }) + vi.stubGlobal('requestAnimationFrame', vi.fn()) + useImageUploadWidget()( + node, + 'upload', + ['IMAGEUPLOAD', { imageInputName: 'image' }], + noApp() + ) + + const uploadWidget = node.widgets?.at(-1) + expect(uploadWidget?.serialize).toBeUndefined() + expect(uploadWidget?.options.serialize).toBe(false) + + expect(proveSerialization(node)).toEqual({ + values: ['x.png', 'image'], + proof: { provable: true, refusal: null, order: ['image', 'upload'] } + }) + }) + + it('excludes the AUDIO_UI player, which is flagged on the widget itself', async () => { + const node = registeredNode('LoadAudio') + Object.defineProperty(node, 'constructor', { + value: fromPartial({ + nodeData: { output_node: false } + }), + configurable: true + }) + node.addWidget('combo', 'audio', 'a.mp3', () => {}, { values: ['a.mp3'] }) + const audioWidgets = await audioWidgetExtension.getCustomWidgets?.(noApp()) + assert.exists(audioWidgets) + audioWidgets.AUDIO_UI(node, 'audioUI', ['AUDIO_UI', {}], noApp()) + node.addWidget('button', 'upload', '', () => {}, { serialize: false }) + + expect( + node.widgets?.map((widget) => [ + widget.name, + widget.serialize, + widget.options.serialize + ]) + ).toEqual([ + ['audio', undefined, undefined], + ['audioUI', false, false], + ['upload', undefined, false] + ]) + + expect(proveSerialization(node)).toEqual({ + values: ['a.mp3', ''], + proof: { provable: true, refusal: null, order: ['audio', 'upload'] } + }) + }) + + it('refuses AUDIO_RECORD, whose player and button share one name', async () => { + const node = registeredNode('RecordAudio') + const recordWidgets = await recordAudioExtension.getCustomWidgets?.(noApp()) + assert.exists(recordWidgets) + recordWidgets.AUDIO_RECORD(node, 'audio', ['AUDIO_RECORD', {}], noApp()) + + expect(node.widgets?.map((widget) => widget.name)).toEqual([ + 'audio', + 'audio' + ]) + expect(proveSerialization(node)).toEqual({ + values: ['', ''], + proof: refusal('duplicate_widget_name') + }) + }) +}) diff --git a/src/lib/litegraph/src/widgets/__fixtures__/widgetFormProofHarness.ts b/src/lib/litegraph/src/widgets/__fixtures__/widgetFormProofHarness.ts new file mode 100644 index 00000000000..e65e7034fc9 --- /dev/null +++ b/src/lib/litegraph/src/widgets/__fixtures__/widgetFormProofHarness.ts @@ -0,0 +1,34 @@ +import type { ISerialisedNode } from '@comfyorg/graph-model/serialisation' +import type { IBaseWidget } from '@comfyorg/graph-model/widgets' + +import { LGraphNode } from '@/lib/litegraph/src/litegraph' + +export interface CapturedSerialization { + final: ISerialisedNode + atCoreSite: unknown + widgetsAtCoreSite: readonly IBaseWidget[] | undefined +} + +export function serializeWithCapture(node: LGraphNode): CapturedSerialization { + let atCoreSite: unknown + let widgetsAtCoreSite: readonly IBaseWidget[] | undefined + const previous = node.onSerialize + node.onSerialize = function (data: ISerialisedNode) { + atCoreSite = data.widgets_values + widgetsAtCoreSite = this.widgets + previous?.call(this, data) + } + try { + return { final: node.serialize(), atCoreSite, widgetsAtCoreSite } + } finally { + node.onSerialize = previous + } +} + +export function coreIsLastWriter(node: LGraphNode): boolean { + return ( + node.serialize === LGraphNode.prototype.serialize && + node.serializeFromStoreState === + LGraphNode.prototype.serializeFromStoreState + ) +} diff --git a/src/lib/litegraph/src/widgets/widgetFormProof.subgraph.test.ts b/src/lib/litegraph/src/widgets/widgetFormProof.subgraph.test.ts new file mode 100644 index 00000000000..0a44946745f --- /dev/null +++ b/src/lib/litegraph/src/widgets/widgetFormProof.subgraph.test.ts @@ -0,0 +1,181 @@ +import { beforeEach, describe, expect, it } from 'vitest' + +import { LegacyWidget, LGraphNode } from '@/lib/litegraph/src/litegraph' +import type { Subgraph, SubgraphNode } from '@/lib/litegraph/src/litegraph' +import { + createTestSubgraph, + createTestSubgraphNode, + resetSubgraphFixtureState +} from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers' +import type { CapturedSerialization } from '@/lib/litegraph/src/widgets/__fixtures__/widgetFormProofHarness' +import { + coreIsLastWriter, + serializeWithCapture +} from '@/lib/litegraph/src/widgets/__fixtures__/widgetFormProofHarness' +import { proveWidgetForm } from '@/lib/litegraph/src/widgets/widgetFormProof' +import type { WidgetFormProof } from '@/lib/litegraph/src/widgets/widgetFormProof' + +function proveAgainstFinalPayload( + node: LGraphNode, + captured: CapturedSerialization, + claimedLastWriter = coreIsLastWriter(node) +) { + return proveWidgetForm(node.widgets, captured.final, captured.atCoreSite, { + serializeWidgets: node.serialize_widgets, + replayed: false, + coreIsLastWriter: claimedLastWriter + }) +} + +function proveAgainstCoreSitePayload( + node: LGraphNode, + captured: CapturedSerialization +) { + return proveWidgetForm( + captured.widgetsAtCoreSite, + { widgets_values: captured.atCoreSite }, + captured.atCoreSite, + { + serializeWidgets: node.serialize_widgets, + replayed: false, + coreIsLastWriter: coreIsLastWriter(node) + } + ) +} + +function interiorNode(widgetName: string, value: number): LGraphNode { + const node = new LGraphNode('Interior') + const input = node.addInput(widgetName, 'number') + node.addOutput('out', 'number') + const widget: LegacyWidget = new LegacyWidget( + { name: widgetName, type: 'number', value, y: 0, options: {}, node }, + node + ) + node.widgets = [widget] + input.widget = { name: widget.name } + return node +} + +function subgraphHostWithPromotedInputs( + names: readonly string[] +): SubgraphNode { + const subgraph: Subgraph = createTestSubgraph({ + inputs: names.map((name) => ({ name, type: 'number' as const })) + }) + for (const [index, name] of names.entries()) { + const interior = interiorNode(name, index + 1) + subgraph.add(interior) + subgraph.inputNode.slots[index].connect(interior.inputs[0], interior) + } + const host = createTestSubgraphNode(subgraph) + host.serialize_widgets = true + return host +} + +function clearPromotedValues(node: SubgraphNode): void { + for (const widget of node.widgets) widget.value = undefined +} + +function refusal(reason: NonNullable) { + return { provable: false, refusal: reason, order: null } +} + +beforeEach(() => { + resetSubgraphFixtureState() +}) + +describe('the capture harness itself', () => { + it('observes the produced values without replacing them, so a plain node still proves', () => { + const node = new LGraphNode('Plain') + node.serialize_widgets = true + node.addWidget('number', 'seed', 1, () => {}) + node.addWidget('text', 'prompt', 'hi', () => {}) + + const captured = serializeWithCapture(node) + + expect(captured.final.widgets_values).toBe(captured.atCoreSite) + expect(proveAgainstFinalPayload(node, captured)).toEqual({ + provable: true, + refusal: null, + order: ['seed', 'prompt'] + }) + }) +}) + +describe('case 1 — subgraph nodes', () => { + it('refuses a subgraph host, whose serializeFromStoreState rebuilds widgets_values after core', () => { + const host = subgraphHostWithPromotedInputs(['alpha', 'beta']) + + const captured = serializeWithCapture(host) + + expect(captured.final.widgets_values).toEqual([1, 2]) + expect(captured.final.widgets_values).not.toBe(captured.atCoreSite) + expect(proveAgainstFinalPayload(host, captured)).toEqual( + refusal('class_may_rewrite_payload') + ) + }) + + it('still refuses by array identity when a caller wrongly claims core wrote the final payload', () => { + const host = subgraphHostWithPromotedInputs(['alpha', 'beta']) + + const captured = serializeWithCapture(host) + + expect(proveAgainstFinalPayload(host, captured, true)).toEqual( + refusal('values_replaced') + ) + }) + + it('refuses when the subgraph deletes widgets_values because every promoted value is undefined', () => { + const host = subgraphHostWithPromotedInputs(['alpha']) + clearPromotedValues(host) + + const captured = serializeWithCapture(host) + + expect('widgets_values' in captured.final).toBe(false) + expect(proveAgainstFinalPayload(host, captured)).toEqual( + refusal('class_may_rewrite_payload') + ) + }) +}) + +describe('case 2 — promoted widgets', () => { + it('counts every promoted input at core write site, because a projection carries no own serialize flag', () => { + const host = subgraphHostWithPromotedInputs(['alpha', 'beta']) + + expect(host.widgets.map((widget) => widget.name)).toEqual(['alpha', 'beta']) + expect( + host.widgets.some((widget) => Object.hasOwn(widget, 'serialize')) + ).toBe(false) + + const captured = serializeWithCapture(host) + expect(captured.atCoreSite).toEqual([1, 2]) + }) + + it('refuses a host whose added widget core serializes but the subgraph rebuild then drops', () => { + const host = subgraphHostWithPromotedInputs(['alpha']) + host.addWidget('text', 'extra', 'hello', () => {}) + + const captured = serializeWithCapture(host) + + expect(captured.atCoreSite).toEqual([1, 'hello']) + expect(captured.final.widgets_values).toEqual([1]) + expect(proveAgainstFinalPayload(host, captured)).toEqual( + refusal('class_may_rewrite_payload') + ) + }) +}) + +describe('the last writer', () => { + it('refuses a subgraph host at core own post-hook payload, before the subclass rewrites it', () => { + const host = subgraphHostWithPromotedInputs(['alpha']) + host.addWidget('text', 'extra', 'hello', () => {}) + + const captured = serializeWithCapture(host) + + expect(captured.atCoreSite).toEqual([1, 'hello']) + expect(captured.final.widgets_values).toEqual([1]) + expect(proveAgainstCoreSitePayload(host, captured)).toEqual( + refusal('class_may_rewrite_payload') + ) + }) +})