test: processors can return subpaths (#19425)

mdjermanovic · web-flow · commit 5fd211d00b6f · 2025-02-12T11:38:43.000-05:00
diff --git a/tests/fixtures/processors/test/test-subpath.txt b/tests/fixtures/processors/test/test-subpath.txt
@@ -0,0 +1 @@
+foo bar baz
diff --git a/tests/lib/eslint/eslint.js b/tests/lib/eslint/eslint.js
@@ -3876,6 +3876,75 @@ describe("ESLint", () => {
 
                 });
 
+                // https://github.com/eslint/markdown/blob/main/rfcs/configure-file-name-from-block-meta.md#name-uniqueness
+                it("should allow processors to return filenames with a slash and treat them as subpaths", async () => {
+                    eslint = new ESLint({
+                        flags,
+                        overrideConfigFile: true,
+                        overrideConfig: [
+                            {
+                                plugins: {
+                                    test: {
+                                        processors: {
+                                            txt: {
+                                                preprocess(input) {
+                                                    return input.split(" ").map((text, index) => ({
+                                                        filename: `example-${index}/a.js`,
+                                                        text
+                                                    }));
+                                                },
+                                                postprocess(messagesList) {
+                                                    return messagesList.flat();
+                                                }
+                                            }
+                                        },
+                                        rules: {
+                                            "test-rule": {
+                                                meta: {},
+                                                create(context) {
+                                                    return {
+                                                        Identifier(node) {
+                                                            context.report({
+                                                                node,
+                                                                message: `filename: ${context.filename} physicalFilename: ${context.physicalFilename} identifier: ${node.name}`
+                                                            });
+                                                        }
+                                                    };
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            },
+                            {
+                                files: ["**/*.txt"],
+                                processor: "test/txt"
+                            },
+                            {
+                                files: ["**/a.js"],
+                                rules: {
+                                    "test/test-rule": "error"
+                                }
+                            }
+                        ],
+                        cwd: path.join(fixtureDir, "..")
+                    });
+                    const filename = getFixturePath("processors", "test", "test-subpath.txt");
+                    const [result] = await eslint.lintFiles([filename]);
+
+                    assert.strictEqual(result.messages.length, 3);
+
+                    assert.strictEqual(result.messages[0].ruleId, "test/test-rule");
+                    assert.strictEqual(result.messages[0].message, `filename: ${path.join(filename, "0_example-0", "a.js")} physicalFilename: ${filename} identifier: foo`);
+                    assert.strictEqual(result.messages[1].ruleId, "test/test-rule");
+                    assert.strictEqual(result.messages[1].message, `filename: ${path.join(filename, "1_example-1", "a.js")} physicalFilename: ${filename} identifier: bar`);
+                    assert.strictEqual(result.messages[2].ruleId, "test/test-rule");
+                    assert.strictEqual(result.messages[2].message, `filename: ${path.join(filename, "2_example-2", "a.js")} physicalFilename: ${filename} identifier: baz`);
+
+                    assert.strictEqual(result.suppressedMessages.length, 0);
+
+                });
+
                 describe("autofixing with processors", () => {
                     const HTML_PROCESSOR = Object.freeze({
                         preprocess(text) {
diff --git a/tests/lib/linter/linter.js b/tests/lib/linter/linter.js
@@ -16945,6 +16945,55 @@ var a = "test2";
                     }
                 ]);
             });
+
+            // https://github.com/eslint/markdown/blob/main/rfcs/configure-file-name-from-block-meta.md#name-uniqueness
+            it("should allow preprocessor to return filenames with a slash and treat them as subpaths.", () => {
+                const problems = linter.verify(
+                    "foo bar baz",
+                    [
+                        {
+                            files: [filename],
+                            processor: {
+                                preprocess(input) {
+                                    return input.split(" ").map(text => ({
+                                        filename: "example/block.js",
+                                        text
+                                    }));
+                                },
+                                postprocess(messagesList) {
+                                    return messagesList.flat();
+                                }
+                            }
+                        },
+                        extraConfig,
+                        {
+                            files: ["**/block.js"],
+                            rules: {
+                                "test/report-original-text": "error"
+                            }
+                        }
+                    ],
+                    {
+                        filename
+                    }
+                );
+                const suppressedMessages = linter.getSuppressedMessages();
+
+                assert.strictEqual(problems.length, 3);
+                assert.deepStrictEqual(problems.map(problem => problem.message), ["foo", "bar", "baz"]);
+
+                assert.strictEqual(suppressedMessages.length, 0);
+
+                // filename
+                assert.strictEqual(receivedFilenames.length, 3);
+                assert.match(receivedFilenames[0], /^filename\.js[/\\]0_example[/\\]block\.js/u);
+                assert.match(receivedFilenames[1], /^filename\.js[/\\]1_example[/\\]block\.js/u);
+                assert.match(receivedFilenames[2], /^filename\.js[/\\]2_example[/\\]block\.js/u);
+
+                // physical filename
+                assert.strictEqual(receivedPhysicalFilenames.length, 3);
+                assert.strictEqual(receivedPhysicalFilenames.every(name => name === filename), true);
+            });
         });
 
         describe("postprocessors", () => {
