mage-obsidian 1.0.12 → 1.1.1

package/jest.config.js

@@ -1,5 +1,5 @@
 export default {
     testEnvironment: 'node',
     transform: {},
-    testPathIgnorePatterns: ['/__tests__/magento_scenarios/','/node_modules/', '/__tests__/__mocks__/'],
+    testPathIgnorePatterns: ['/__tests__/magento_scenarios/','/node_modules/', '/__tests__/__mocks__/', '/__tests__/fixtures/'],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mage-obsidian",
-  "version": "1.0.12",
+  "version": "1.1.1",
   "description": "Mage Obsidian Ultis",
   "main": "./src/scripts/buildThemes.js",
   "keywords": [
@@ -22,7 +22,8 @@
     ".": "./src/scripts/buildThemes.js",
     "./service/": "./src/service/",
     "./utils/": "./src/utils/",
-    "./config/": "./src/config/"
+    "./config/": "./src/config/",
+    "./service/*": "./src/service/*"
   },
   "dependencies": {
     "chalk": "^5.4.1",

package/src/__tests__/fixtures/interceptors/emptyTarget.js

@@ -0,0 +1,2 @@
+
+export const someOtherFunction = () => {};

package/src/__tests__/fixtures/interceptors/pluginForNonFunction.js

@@ -0,0 +1,7 @@
+
+export function beforeConfig() {
+    console.log('Should not run');
+}
+export function beforeDefault() {
+    console.log('Should not run');
+}

package/src/__tests__/fixtures/interceptors/pluginModule.js

@@ -0,0 +1,13 @@
+
+export function beforeTargetFunction(arg) {
+    return [`Modified: ${arg}`];
+}
+
+export function afterAnotherFunction(result) {
+    return `${result} - Modified`;
+}
+
+export function beforeDefault() {
+    return ['Default Modified'];
+}
+

package/src/__tests__/fixtures/interceptors/targetModule.js

@@ -0,0 +1,12 @@
+
+export function targetFunction(arg) {
+    return `Original: ${arg}`;
+}
+
+export function anotherFunction() {
+    return 'Another';
+}
+
+export default function defaultExport() {
+    return 'Default';
+}

package/src/__tests__/fixtures/interceptors/targetNonFunction.js

@@ -0,0 +1,7 @@
+
+export const config = {
+    some: 'value'
+};
+export default {
+    main: 'config'
+};

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-a/Vendor_ModuleNameA/web/module.config.js

@@ -1,8 +1,2 @@
 export default {
-    tailwind: {
-        content: [
-            '../templates/**/*.phtml',
-            '/from_theme'
-        ]
-    }
 };

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-a/Vendor_ModuleNameB/web/module.config.js

@@ -1,7 +1,2 @@
 export default {
-    tailwind: {
-        content: [
-            '../templates/**/*.phtml'
-        ]
-    }
 };

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-a/Vendor_ModuleNameNoConfig/web/module.config.js

@@ -1,8 +1,2 @@
 export default {
-    tailwind: {
-        content: [
-            '../templates/**/*.phtml',
-            'pollo'
-        ]
-    }
 };

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-a/web/theme.config.js

@@ -1,16 +1,4 @@
 export default {
-    tailwind: {
-        theme: {
-            extend: {},
-        },
-        plugins: [],
-        content: [
-            './**/*.{vue,js}',
-            '../**/*.phtml',
-            '../*/page_layout/override/base/*.xml',
-        ],
-    },
-    ignoredTailwindConfigFromModules: [],
     ignoredCssFromModules: [
         'Vendor_ModuleNameA',
     ],

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-b/web/theme.config.js

@@ -1,21 +1,4 @@
 export default {
-    tailwind: {
-        theme: {
-            extend: {
-                textColor: {
-                    'primary': '#3490dc',
-                    'secondary': '#ffed4a',
-                    'danger': '#e3342f',
-                },
-            },
-        },
-        plugins: [],
-        content: [
-            './**/*.{vue,js}',
-            '../**/*.phtml',
-            '../*/page_layout/override/base/*.xml',
-        ],
-    },
     ignoredCssFromModules: [
         'Vendor_ModuleNameNoConfig'
     ]

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-c/Vendor_ModuleNameB/web/module.config.js

@@ -1,9 +1,2 @@
 export default {
-    tailwind: {
-        plugins: ['test_from_theme'],
-        content: [
-            '../templates/**/*.phtml',
-            '/from_theme'
-        ]
-    }
 };

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-c/web/theme.config.js

@@ -1,16 +1,2 @@
 export default {
-    tailwind: {
-        theme: {
-            extend: {
-            },
-        },
-        plugins: [],
-        content: [
-            './**/*.{vue,js}',
-            '../**/*.phtml',
-            '../*/page_layout/override/base/*.xml',
-        ],
-    },
-    includeTailwindConfigFromParentThemes: false,
-    ignoredTailwindConfigFromModules: 'all'
 }

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-d/web/theme.config.js

@@ -1,14 +1,3 @@
 export default {
-    tailwind: {
-        theme: {
-            extend: {
-            },
-        },
-        plugins: [],
-        content: [],
-    },
-    ignoredTailwindConfigFromModules: [
-        'Vendor_ModuleNameC'
-    ],
     includeCssSourceFromParentThemes: false,
 }

package/src/__tests__/service/generateInterceptors.test.js

@@ -0,0 +1,196 @@
+
+import { jest } from '@jest/globals';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const fixturesDir = path.resolve(__dirname, '../fixtures/interceptors');
+const targetModulePath = path.join(fixturesDir, 'targetModule.js');
+const pluginModulePath = path.join(fixturesDir, 'pluginModule.js');
+const targetNonFunctionPath = path.join(fixturesDir, 'targetNonFunction.js');
+const pluginForNonFunctionPath = path.join(fixturesDir, 'pluginForNonFunction.js');
+
+describe('generateInterceptors', () => {
+    let generateInterceptorsService;
+    let themeResolverMock;
+    let moduleResolverMock;
+    let interceptorManager;
+
+    beforeEach(async () => {
+        jest.resetModules();
+
+        themeResolverMock = {
+            getThemeConfig: jest.fn(),
+        };
+
+        moduleResolverMock = {
+            getModuleConfigByThemeConfig: jest.fn(),
+            getAllJsVueFilesWithInheritanceCached: jest.fn(),
+            getAllJsVueFilesWithInheritance: jest.fn(),
+        };
+
+        jest.unstable_mockModule('../../service/themeResolverSync.js', () => ({
+            default: themeResolverMock
+        }));
+
+        jest.unstable_mockModule('../../service/moduleResolver.js', () => ({
+            default: moduleResolverMock
+        }));
+
+        jest.unstable_mockModule('../../service/configResolver.js', () => ({
+            default: {
+                resolveLibRealPath: jest.fn().mockReturnValue('/mocked/path/to/interceptorManager')
+            }
+        }));
+
+        // Import real interceptorManager to reset state
+        interceptorManager = (await import('../../service/interceptorManager.js')).default;
+        interceptorManager.interceptors = {};
+
+        generateInterceptorsService = (await import('../../service/generateInterceptors.js')).default;
+    });
+
+    test('should generate interceptors correctly', async () => {
+        const themeName = 'Vendor/theme-test';
+
+        themeResolverMock.getThemeConfig.mockReturnValue({
+            src: '/path/to/theme'
+        });
+
+        moduleResolverMock.getModuleConfigByThemeConfig.mockResolvedValue({
+            interceptors: {
+                'TestPlugin': {
+                    name: 'TestPlugin',
+                    target: 'Vendor_TargetModule::js/target.js',
+                    interceptor: 'Vendor_PluginModule::js/plugin.js',
+                    sortOrder: 10,
+                    active: true
+                }
+            }
+        });
+
+        const allFilesMap = {
+            'Vendor_TargetModule/js/target': targetModulePath,
+            'Vendor_PluginModule/js/plugin': pluginModulePath
+        };
+
+        moduleResolverMock.getAllJsVueFilesWithInheritanceCached.mockReturnValue(allFilesMap);
+
+        const result = await generateInterceptorsService.generateInterceptors(themeName);
+
+        const targetIdentifier = 'Vendor_TargetModule::js/target.js';
+        // Use bracket access check to avoid Jest treating '.' as nested property
+        expect(result[targetIdentifier]).toBeDefined();
+
+        const interceptorData = result[targetIdentifier];
+        expect(interceptorData).toHaveProperty('proxy');
+        expect(interceptorData).toHaveProperty('source');
+        expect(interceptorData).toHaveProperty('targetPath', targetModulePath);
+        expect(interceptorData.interceptors).toHaveLength(1);
+        expect(interceptorData.interceptors[0].name).toBe('TestPlugin');
+
+        // Verify Source Code Generation
+        const source = interceptorData.source;
+        expect(source).toContain(`import * as originalModule from '/@fs${targetModulePath}?originalIntercepted';`);
+        expect(source).toContain(`import * as interceptor_0 from '/@fs${pluginModulePath}';`);
+        expect(source).toContain(`interceptorManager.addInterceptor('${targetIdentifier}::targetFunction', 'TestPlugin', 'before', interceptor_0.beforeTargetFunction, 10);`);
+        expect(source).toContain(`interceptorManager.addInterceptor('${targetIdentifier}::default', 'TestPlugin', 'before', interceptor_0.beforeDefault, 10);`);
+        expect(source).toContain(`export const targetFunction = proxy.targetFunction;`);
+
+        // Verify Proxy Behavior
+        const proxy = interceptorData.proxy;
+        const resultFunc = await proxy.targetFunction('test');
+        expect(resultFunc).toBe('Original: Modified: test');
+
+        const resultAnother = await proxy.anotherFunction();
+        expect(resultAnother).toBe('Another - Modified');
+
+        const resultDefault = await proxy.default();
+        expect(resultDefault).toBe('Default'); // The mock plugin returns ['Default Modified'] but the original function ignores args and returns 'Default'. 
+        // Wait, before interceptor modifies arguments. 
+        // targetModule.js: export default function defaultExport() { return 'Default'; }
+        // It doesn't take arguments, so modifying arguments won't change output unless we check arguments.
+        // But we just want to verify it was registered.
+
+    });
+
+    test('should handle missing target module gracefully', async () => {
+        themeResolverMock.getThemeConfig.mockReturnValue({});
+        moduleResolverMock.getModuleConfigByThemeConfig.mockResolvedValue({
+            'Vendor_TargetModule': { interceptors: [] }
+        });
+        moduleResolverMock.getAllJsVueFilesWithInheritanceCached.mockReturnValue({});
+
+        const result = await generateInterceptorsService.generateInterceptors('Vendor/theme-missing');
+        expect(result).toEqual({});
+    });
+
+    test('should throw error if plugin targets non-existent method', async () => {
+        const themeName = 'Vendor/theme-test';
+        themeResolverMock.getThemeConfig.mockReturnValue({});
+        moduleResolverMock.getModuleConfigByThemeConfig.mockResolvedValue({
+            interceptors: {
+                'BadPlugin': {
+                    name: 'BadPlugin',
+                    target: 'Vendor_TargetModule::js/target.js',
+                    interceptor: 'Vendor_PluginModule::js/plugin.js',
+                    sortOrder: 10
+                }
+            }
+        });
+
+        const emptyTargetModulePath = path.join(fixturesDir, 'emptyTarget.js');
+        
+        const allFilesMap = {
+            'Vendor_TargetModule/js/target': emptyTargetModulePath,
+            'Vendor_PluginModule/js/plugin': pluginModulePath
+        };
+        
+        moduleResolverMock.getAllJsVueFilesWithInheritanceCached.mockReturnValue(allFilesMap);
+
+        // We expect the promise to reject because generateInterceptors throws on invalid target method
+        await expect(generateInterceptorsService.generateInterceptors(themeName))
+            .rejects
+            .toThrow(/does not export/);
+    });
+
+    test('should skip interception for non-function exports', async () => {
+        const themeName = 'Vendor/theme-test';
+
+        themeResolverMock.getThemeConfig.mockReturnValue({
+            src: '/path/to/theme'
+        });
+
+        moduleResolverMock.getModuleConfigByThemeConfig.mockResolvedValue({
+            interceptors: {
+                'TestPlugin': {
+                    name: 'TestPlugin',
+                    target: 'Vendor_TargetModule::js/targetNonFunction.js',
+                    interceptor: 'Vendor_PluginModule::js/pluginForNonFunction.js',
+                    sortOrder: 10,
+                    active: true
+                }
+            }
+        });
+
+        const allFilesMap = {
+            'Vendor_TargetModule/js/targetNonFunction': targetNonFunctionPath,
+            'Vendor_PluginModule/js/pluginForNonFunction': pluginForNonFunctionPath
+        };
+
+        moduleResolverMock.getAllJsVueFilesWithInheritanceCached.mockReturnValue(allFilesMap);
+
+        const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+        const result = await generateInterceptorsService.generateInterceptors(themeName);
+
+        const targetIdentifier = 'Vendor_TargetModule::js/targetNonFunction.js';
+        
+        // Since both 'config' and 'default' are objects, and we are trying to intercept them,
+        // they should be skipped. If all are skipped, the targetIdentifier should not be in result.
+        expect(result[targetIdentifier]).toBeUndefined();
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('is not a function'));
+
+        consoleSpy.mockRestore();
+    });
+});

package/src/__tests__/service/interceptorManager_magento_behavior.test.js

@@ -0,0 +1,137 @@
+
+import { jest } from '@jest/globals';
+import interceptorManager from '../../service/interceptorManager.js';
+
+describe('InterceptorManager Magento Behavior', () => {
+    beforeEach(() => {
+        // Reset interceptors before each test
+        interceptorManager.interceptors = {};
+    });
+
+    test('Before interceptors: should chain arguments and handle null returns', async () => {
+        const targetName = 'Test::beforeChain';
+        const originalFn = jest.fn((arg1, arg2) => `Original: ${arg1}, ${arg2}`);
+        const context = {};
+
+        // Interceptor 1: Modifies arguments
+        const beforeInterceptor1 = jest.fn((arg1, arg2) => {
+            return [arg1 + '_mod1', arg2 + '_mod1'];
+        });
+
+        // Interceptor 2: Returns null (should keep arguments from Interceptor 1)
+        const beforeInterceptor2 = jest.fn((arg1, arg2) => {
+            return null;
+        });
+
+        // Interceptor 3: Modifies arguments again
+        const beforeInterceptor3 = jest.fn((arg1, arg2) => {
+            return [arg1 + '_mod3', arg2 + '_mod3'];
+        });
+
+        interceptorManager.addInterceptor(targetName, 'Interceptor1', 'before', beforeInterceptor1, 10);
+        interceptorManager.addInterceptor(targetName, 'Interceptor2', 'before', beforeInterceptor2, 20);
+        interceptorManager.addInterceptor(targetName, 'Interceptor3', 'before', beforeInterceptor3, 30);
+
+        const result = await interceptorManager.execute(targetName, originalFn, context, 'A', 'B');
+
+        // Verify Interceptor 1 received original args
+        expect(beforeInterceptor1).toHaveBeenCalledWith('A', 'B');
+
+        // Verify Interceptor 2 received args modified by Interceptor 1
+        expect(beforeInterceptor2).toHaveBeenCalledWith('A_mod1', 'B_mod1');
+
+        // Verify Interceptor 3 received args from Interceptor 1 (since Interceptor 2 returned null)
+        expect(beforeInterceptor3).toHaveBeenCalledWith('A_mod1', 'B_mod1');
+
+        // Verify Original received args modified by Interceptor 3
+        expect(originalFn).toHaveBeenCalledWith('A_mod1_mod3', 'B_mod1_mod3');
+
+        expect(result).toBe('Original: A_mod1_mod3, B_mod1_mod3');
+    });
+
+    test('Around interceptors: should wrap execution and modify args/result', async () => {
+        const targetName = 'Test::aroundChain';
+        const originalFn = jest.fn((arg) => `Original(${arg})`);
+        const context = {};
+
+        // Outer Around Interceptor
+        const aroundInterceptor1 = jest.fn(async (proceed, arg) => {
+            const result = await proceed(arg + '_outerIn');
+            return `Outer(${result})`;
+        });
+
+        // Inner Around Interceptor
+        const aroundInterceptor2 = jest.fn(async (proceed, arg) => {
+            const result = await proceed(arg + '_innerIn');
+            return `Inner(${result})`;
+        });
+
+        interceptorManager.addInterceptor(targetName, 'Interceptor1', 'around', aroundInterceptor1, 10);
+        interceptorManager.addInterceptor(targetName, 'Interceptor2', 'around', aroundInterceptor2, 20);
+
+        const result = await interceptorManager.execute(targetName, originalFn, context, 'Start');
+
+        // Execution flow:
+        // Interceptor1 (Start) -> calls proceed('Start_outerIn')
+        //   -> Interceptor2 ('Start_outerIn') -> calls proceed('Start_outerIn_innerIn')
+        //     -> Original ('Start_outerIn_innerIn') -> returns 'Original(Start_outerIn_innerIn)'
+        //   -> Interceptor2 returns 'Inner(Original(Start_outerIn_innerIn))'
+        // -> Interceptor1 returns 'Outer(Inner(Original(Start_outerIn_innerIn)))'
+
+        expect(originalFn).toHaveBeenCalledWith('Start_outerIn_innerIn');
+        expect(result).toBe('Outer(Inner(Original(Start_outerIn_innerIn)))');
+    });
+
+    test('After interceptors: should chain results', async () => {
+        const targetName = 'Test::afterChain';
+        const originalFn = jest.fn(() => 'Original');
+        const context = {};
+
+        const afterInterceptor1 = jest.fn((result) => {
+            return result + '_After1';
+        });
+
+        const afterInterceptor2 = jest.fn((result) => {
+            return result + '_After2';
+        });
+
+        interceptorManager.addInterceptor(targetName, 'Interceptor1', 'after', afterInterceptor1, 10);
+        interceptorManager.addInterceptor(targetName, 'Interceptor2', 'after', afterInterceptor2, 20);
+
+        const result = await interceptorManager.execute(targetName, originalFn, context);
+
+        expect(afterInterceptor1).toHaveBeenCalledWith('Original');
+        expect(afterInterceptor2).toHaveBeenCalledWith('Original_After1');
+        expect(result).toBe('Original_After1_After2');
+    });
+
+    test('Full Chain: Before -> Around -> Original -> After', async () => {
+        const targetName = 'Test::fullChain';
+        const originalFn = jest.fn((arg) => `Original(${arg})`);
+        const context = {};
+
+        // Before: Modifies arg
+        interceptorManager.addInterceptor(targetName, 'Before', 'before', (arg) => [arg + '_Before'], 10);
+
+        // Around: Wraps and modifies arg further
+        interceptorManager.addInterceptor(targetName, 'Around', 'around', async (proceed, arg) => {
+            const res = await proceed(arg + '_AroundIn');
+            return `Around(${res})`;
+        }, 20);
+
+        // After: Modifies result
+        interceptorManager.addInterceptor(targetName, 'After', 'after', (res) => res + '_After', 30);
+
+        const result = await interceptorManager.execute(targetName, originalFn, context, 'Start');
+
+        // Flow:
+        // Before: Start -> Start_Before
+        // Around: Start_Before -> calls proceed(Start_Before_AroundIn)
+        // Original: Start_Before_AroundIn -> returns Original(Start_Before_AroundIn)
+        // Around: returns Around(Original(Start_Before_AroundIn))
+        // After: receives Around(...) -> returns Around(...)_After
+
+        expect(originalFn).toHaveBeenCalledWith('Start_Before_AroundIn');
+        expect(result).toBe('Around(Original(Start_Before_AroundIn))_After');
+    });
+});

package/src/__tests__/service/themeResolverSync.test.js

@@ -12,90 +12,40 @@ let scenarios = [
             {
                 code: 'Vendor/theme-a',
                 expected: {
-                    tailwind: {
-                        theme: { extend: {} },
-                        plugins: [],
-                        content: [
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/web/**/*.{vue,js}',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/**/*.phtml',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/*/page_layout/override/base/*.xml'
-                        ]
-                    },
-                    includeTailwindConfigFromParentThemes: true,
                     includeCssSourceFromParentThemes: true,
                     ignoredCssFromModules: [
                          'Vendor_ModuleNameA'
                     ],
-                    ignoredTailwindConfigFromModules: [],
                     exposeNpmPackages: []
                 }
             },
             {
                 code: 'Vendor/theme-b',
                 expected: {
-                    tailwind: {
-                        theme: {
-                            extend: {
-                                textColor: {
-                                    'primary': '#3490dc',
-                                    'secondary': '#ffed4a',
-                                    'danger': '#e3342f',
-                                },
-                            }
-                        },
-                        plugins: [],
-                        content: [
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/web/**/*.{vue,js}',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/**/*.phtml',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/*/page_layout/override/base/*.xml',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-b/web/**/*.{vue,js}',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-b/**/*.phtml',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-b/*/page_layout/override/base/*.xml'
-                        ]
-                    },
-                    includeTailwindConfigFromParentThemes: true,
                     includeCssSourceFromParentThemes: true,
                     ignoredCssFromModules: [
                         'Vendor_ModuleNameA',
                         'Vendor_ModuleNameNoConfig'
                     ],
-                    ignoredTailwindConfigFromModules: [],
                     exposeNpmPackages: []
                 }
             },
             {
                 code: 'Vendor/theme-c',
                 expected: {
-                    tailwind: {
-                        theme: { extend: {} },
-                        plugins: [],
-                        content: [
-                            'magento_scenarios/app/design/frontend/Vendor/theme-c/web/**/*.{vue,js}',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-c/**/*.phtml',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-c/*/page_layout/override/base/*.xml'
-                        ]
-                    },
-                    includeTailwindConfigFromParentThemes: false,
                     includeCssSourceFromParentThemes: true,
-                    ignoredCssFromModules: [],
-                    ignoredTailwindConfigFromModules: 'all',
+                    ignoredCssFromModules: [
+                        'Vendor_ModuleNameA',
+                        'Vendor_ModuleNameNoConfig'
+                    ],
                     exposeNpmPackages: []
                 }
             },
             {
                 code: 'Vendor/theme-d',
                 expected: {
-                    tailwind: {
-                        theme: { extend: {} },
-                        plugins: [],
-                        content: []
-                    },
-                    includeTailwindConfigFromParentThemes: true,
                     includeCssSourceFromParentThemes: false,
                     ignoredCssFromModules: [],
-                    ignoredTailwindConfigFromModules: [
-                        'Vendor_ModuleNameC'
-                    ],
                     exposeNpmPackages: []
                 }
             }
@@ -107,7 +57,6 @@ for (const scenario of scenarios) {
     for (const themeKey in scenario.themes) {
         let theme = scenario.themes[themeKey];
         const expected = theme.expected;
-        expected.tailwind.content = expected.tailwind.content?.map((content) => path.resolve(__dirname, '..', content));
     }
 }
 
@@ -145,24 +94,4 @@ describe('getThemeConfig', () => {
     });
 });
 
-describe('getTailwindThemeConfig', () => {
-    let themeResolver;
-
-    beforeEach(() => {
-        jest.resetModules();
-    });
-
-    test.each(scenarios.flatMap(({ scenario, themes }) =>
-        themes.map(({ code, expected }) => ([ scenario, code, expected ]))
-    ))('Scenario "%s", Theme "%s"', async ( scenario, code, expected ) => {
-        themeResolver = await setupThemeResolver(scenario);
-
-        const result = await themeResolver.getTailwindThemeConfig(code);
-
-        expect(result).toMatchObject(
-            expected.tailwind,
-            `Expected:\n${JSON.stringify(expected.tailwind, null, 2)}\nReceived:\n${JSON.stringify(result, null, 2)}\nScenario: "${scenario}", Theme: "${code}"`
-        );
-    });
-});