@tanstack/cta-engine 0.27.1 → 0.29.0

package/tests/conditional-packages.test.ts

@@ -0,0 +1,418 @@
+import { describe, expect, it } from 'vitest'
+
+import { createPackageJSON, mergePackageJSON } from '../src/package-json.js'
+import type { Options, Framework } from '../src/types.js'
+
+describe('Conditional Package Dependencies', () => {
+  const baseFramework = {
+    basePackageJSON: {
+      version: '1.0.0',
+      type: 'module'
+    },
+    optionalPackages: {}
+  } as unknown as Framework
+
+  const baseOptions = {
+    projectName: 'test-app',
+    framework: baseFramework,
+    mode: 'file-router',
+    typescript: true,
+    tailwind: false,
+    packageManager: 'pnpm',
+    chosenAddOns: [],
+    addOnOptions: {}
+  } as unknown as Options
+
+  describe('EJS Template Processing', () => {
+    it('should process packageTemplate with conditional dependencies', () => {
+      const options = {
+        ...baseOptions,
+        chosenAddOns: [
+          {
+            id: 'testAddon',
+            name: 'Drizzle ORM',
+            packageTemplate: `{
+              "dependencies": {
+                "testAddon-orm": "^0.29.0"<% if (addOnOption.testAddon.database === 'postgres') { %>,
+                "postgres": "^3.4.0"<% } %><% if (addOnOption.testAddon.database === 'mysql') { %>,
+                "mysql2": "^3.6.0"<% } %><% if (addOnOption.testAddon.database === 'sqlite') { %>,
+                "better-sqlite3": "^8.7.0"<% } %>
+              },
+              "devDependencies": {<% if (addOnOption.testAddon.database === 'postgres') { %>
+                "@types/postgres": "^3.0.0"<% } %><% if (addOnOption.testAddon.database === 'mysql') { %>
+                "@types/mysql2": "^3.0.0"<% } %><% if (addOnOption.testAddon.database === 'sqlite') { %>
+                "@types/better-sqlite3": "^7.6.0"<% } %>
+              }
+            }`
+          }
+        ],
+        addOnOptions: {
+          testAddon: {
+            database: 'postgres'
+          }
+        }
+      }
+
+      const packageJSON = createPackageJSON(options)
+
+      expect(packageJSON.dependencies).toEqual({
+        'testAddon-orm': '^0.29.0',
+        'postgres': '^3.4.0'
+      })
+      expect(packageJSON.devDependencies).toEqual({
+        '@types/postgres': '^3.0.0'
+      })
+      // MySQL and SQLite dependencies should not be included
+      expect(packageJSON.dependencies).not.toHaveProperty('mysql2')
+      expect(packageJSON.dependencies).not.toHaveProperty('better-sqlite3')
+      expect(packageJSON.devDependencies).not.toHaveProperty('@types/mysql2')
+      expect(packageJSON.devDependencies).not.toHaveProperty('@types/better-sqlite3')
+    })
+
+    it('should handle different database options correctly', () => {
+      const options = {
+        ...baseOptions,
+        chosenAddOns: [
+          {
+            id: 'testAddon',
+            name: 'Drizzle ORM',
+            packageTemplate: `{
+              "dependencies": {
+                "testAddon-orm": "^0.29.0"<% if (addOnOption.testAddon.database === 'postgres') { %>,
+                "postgres": "^3.4.0"<% } %><% if (addOnOption.testAddon.database === 'mysql') { %>,
+                "mysql2": "^3.6.0"<% } %><% if (addOnOption.testAddon.database === 'sqlite') { %>,
+                "better-sqlite3": "^8.7.0"<% } %>
+              }
+            }`
+          }
+        ],
+        addOnOptions: {
+          testAddon: {
+            database: 'mysql'
+          }
+        }
+      }
+
+      const packageJSON = createPackageJSON(options)
+
+      expect(packageJSON.dependencies).toEqual({
+        'testAddon-orm': '^0.29.0',
+        'mysql2': '^3.6.0'
+      })
+      // PostgreSQL and SQLite dependencies should not be included
+      expect(packageJSON.dependencies).not.toHaveProperty('postgres')
+      expect(packageJSON.dependencies).not.toHaveProperty('better-sqlite3')
+    })
+
+    it('should handle SQLite option correctly', () => {
+      const options = {
+        ...baseOptions,
+        chosenAddOns: [
+          {
+            id: 'testAddon',
+            name: 'Drizzle ORM',
+            packageTemplate: `{
+              "dependencies": {
+                "testAddon-orm": "^0.29.0"<% if (addOnOption.testAddon.database === 'postgres') { %>,
+                "postgres": "^3.4.0"<% } %><% if (addOnOption.testAddon.database === 'mysql') { %>,
+                "mysql2": "^3.6.0"<% } %><% if (addOnOption.testAddon.database === 'sqlite') { %>,
+                "better-sqlite3": "^8.7.0"<% } %>
+              },
+              "devDependencies": {<% if (addOnOption.testAddon.database === 'sqlite') { %>
+                "@types/better-sqlite3": "^7.6.0"<% } %>
+              }
+            }`
+          }
+        ],
+        addOnOptions: {
+          testAddon: {
+            database: 'sqlite'
+          }
+        }
+      }
+
+      const packageJSON = createPackageJSON(options)
+
+      expect(packageJSON.dependencies).toEqual({
+        'testAddon-orm': '^0.29.0',
+        'better-sqlite3': '^8.7.0'
+      })
+      expect(packageJSON.devDependencies).toEqual({
+        '@types/better-sqlite3': '^7.6.0'
+      })
+    })
+
+    it('should handle multiple add-ons with options', () => {
+      const options = {
+        ...baseOptions,
+        chosenAddOns: [
+          {
+            id: 'testAddon',
+            name: 'Drizzle ORM',
+            packageTemplate: `{
+              "dependencies": {
+                "testAddon-orm": "^0.29.0"<% if (addOnOption.testAddon.database === 'postgres') { %>,
+                "postgres": "^3.4.0"<% } %>
+              }
+            }`
+          },
+          {
+            id: 'auth',
+            name: 'Authentication',
+            packageTemplate: `{
+              "dependencies": {<% if (addOnOption.auth.provider === 'auth0') { %>
+                "@auth0/nextjs-auth0": "^3.0.0"<% } %><% if (addOnOption.auth.provider === 'supabase') { %>
+                "@supabase/supabase-js": "^2.0.0"<% } %>
+              }
+            }`
+          }
+        ],
+        addOnOptions: {
+          testAddon: {
+            database: 'postgres'
+          },
+          auth: {
+            provider: 'auth0'
+          }
+        }
+      }
+
+      const packageJSON = createPackageJSON(options)
+
+      expect(packageJSON.dependencies).toEqual({
+        'testAddon-orm': '^0.29.0',
+        'postgres': '^3.4.0',
+        '@auth0/nextjs-auth0': '^3.0.0'
+      })
+      expect(packageJSON.dependencies).not.toHaveProperty('@supabase/supabase-js')
+    })
+
+    it('should handle complex conditional logic', () => {
+      const options = {
+        ...baseOptions,
+        chosenAddOns: [
+          {
+            id: 'ui',
+            name: 'UI Library',
+            packageTemplate: `{
+              "dependencies": {<% if (addOnOption.ui.library === 'chakra') { %>
+                "@chakra-ui/react": "^2.0.0",
+                "@emotion/react": "^11.0.0",
+                "@emotion/styled": "^11.0.0"<% } else if (addOnOption.ui.library === 'mui') { %>
+                "@mui/material": "^5.0.0",
+                "@emotion/react": "^11.0.0",
+                "@emotion/styled": "^11.0.0"<% } else if (addOnOption.ui.library === 'mantine') { %>
+                "@mantine/core": "^7.0.0",
+                "@mantine/hooks": "^7.0.0"<% } %>
+              }
+            }`
+          }
+        ],
+        addOnOptions: {
+          ui: {
+            library: 'mantine'
+          }
+        }
+      }
+
+      const packageJSON = createPackageJSON(options)
+
+      expect(packageJSON.dependencies).toEqual({
+        '@mantine/core': '^7.0.0',
+        '@mantine/hooks': '^7.0.0'
+      })
+      // Other UI library dependencies should not be included
+      expect(packageJSON.dependencies).not.toHaveProperty('@chakra-ui/react')
+      expect(packageJSON.dependencies).not.toHaveProperty('@mui/material')
+    })
+
+    it('should handle scripts conditionally', () => {
+      const options = {
+        ...baseOptions,
+        chosenAddOns: [
+          {
+            id: 'testing',
+            name: 'Testing Setup',
+            packageTemplate: `{
+              "scripts": {<% if (addOnOption.testing.framework === 'jest') { %>
+                "test": "jest",
+                "test:watch": "jest --watch"<% } else if (addOnOption.testing.framework === 'vitest') { %>
+                "test": "vitest",
+                "test:ui": "vitest --ui"<% } %>
+              },
+              "devDependencies": {<% if (addOnOption.testing.framework === 'jest') { %>
+                "jest": "^29.0.0",
+                "@types/jest": "^29.0.0"<% } else if (addOnOption.testing.framework === 'vitest') { %>
+                "vitest": "^1.0.0",
+                "@vitest/ui": "^1.0.0"<% } %>
+              }
+            }`
+          }
+        ],
+        addOnOptions: {
+          testing: {
+            framework: 'vitest'
+          }
+        }
+      }
+
+      const packageJSON = createPackageJSON(options)
+
+      expect(packageJSON.scripts).toEqual({
+        'test': 'vitest',
+        'test:ui': 'vitest --ui'
+      })
+      expect(packageJSON.devDependencies).toEqual({
+        'vitest': '^1.0.0',
+        '@vitest/ui': '^1.0.0'
+      })
+      // Jest-specific scripts and dependencies should not be included
+      expect(packageJSON.scripts).not.toHaveProperty('test:watch')
+      expect(packageJSON.devDependencies).not.toHaveProperty('jest')
+      expect(packageJSON.devDependencies).not.toHaveProperty('@types/jest')
+    })
+
+    it('should fallback to packageAdditions on template error', () => {
+      const options = {
+        ...baseOptions,
+        chosenAddOns: [
+          {
+            id: 'broken',
+            name: 'Broken Template',
+            packageTemplate: `{
+              "dependencies": {
+                "valid-package": "^1.0.0"
+                <% this will cause a syntax error %>
+              }
+            }`,
+            packageAdditions: {
+              dependencies: {
+                'fallback-package': '^1.0.0'
+              }
+            }
+          }
+        ],
+        addOnOptions: {}
+      }
+
+      const packageJSON = createPackageJSON(options)
+
+      // Should use fallback packageAdditions
+      expect(packageJSON.dependencies).toEqual({
+        'fallback-package': '^1.0.0'
+      })
+      expect(packageJSON.dependencies).not.toHaveProperty('valid-package')
+    })
+
+    it('should handle empty or missing addOnOptions', () => {
+      const options = {
+        ...baseOptions,
+        chosenAddOns: [
+          {
+            id: 'simple',
+            name: 'Simple Add-on',
+            packageTemplate: `{
+              "dependencies": {
+                "always-included": "^1.0.0"<% if (addOnOption.simple && addOnOption.simple.feature) { %>,
+                "conditional-package": "^1.0.0"<% } %>
+              }
+            }`
+          }
+        ],
+        addOnOptions: {} // No options for this add-on
+      }
+
+      const packageJSON = createPackageJSON(options)
+
+      expect(packageJSON.dependencies).toEqual({
+        'always-included': '^1.0.0'
+      })
+      expect(packageJSON.dependencies).not.toHaveProperty('conditional-package')
+    })
+
+    it('should preserve dependency sorting after template processing', () => {
+      const options = {
+        ...baseOptions,
+        chosenAddOns: [
+          {
+            id: 'sorting-test',
+            name: 'Sorting Test',
+            packageTemplate: `{
+              "dependencies": {
+                "z-package": "^1.0.0",
+                "a-package": "^1.0.0",
+                "m-package": "^1.0.0"
+              }
+            }`
+          }
+        ],
+        addOnOptions: {}
+      }
+
+      const packageJSON = createPackageJSON(options)
+      const dependencyKeys = Object.keys(packageJSON.dependencies)
+
+      // Dependencies should be sorted alphabetically
+      expect(dependencyKeys).toEqual(['a-package', 'm-package', 'z-package'])
+    })
+  })
+
+  describe('mergePackageJSON', () => {
+    it('should merge dependencies correctly', () => {
+      const base = {
+        dependencies: {
+          'react': '^18.0.0',
+          'lodash': '^4.0.0'
+        },
+        devDependencies: {
+          'typescript': '^5.0.0'
+        }
+      }
+
+      const overlay = {
+        dependencies: {
+          'axios': '^1.0.0',
+          'lodash': '^4.17.0' // Should override
+        },
+        devDependencies: {
+          'jest': '^29.0.0'
+        }
+      }
+
+      const result = mergePackageJSON(base, overlay)
+
+      expect(result.dependencies).toEqual({
+        'react': '^18.0.0',
+        'lodash': '^4.17.0', // Overridden version
+        'axios': '^1.0.0'
+      })
+      expect(result.devDependencies).toEqual({
+        'typescript': '^5.0.0',
+        'jest': '^29.0.0'
+      })
+    })
+
+    it('should handle missing sections gracefully', () => {
+      const base = {
+        dependencies: {
+          'react': '^18.0.0'
+        }
+      }
+
+      const overlay = {
+        devDependencies: {
+          'jest': '^29.0.0'
+        }
+      }
+
+      const result = mergePackageJSON(base, overlay)
+
+      expect(result.dependencies).toEqual({
+        'react': '^18.0.0'
+      })
+      expect(result.devDependencies).toEqual({
+        'jest': '^29.0.0'
+      })
+    })
+  })
+})

package/tests/filename-processing.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, it } from 'vitest'
+
+import { createMemoryEnvironment } from '../src/environment.js'
+import { createTemplateFile } from '../src/template-file.js'
+
+import type { Options } from '../src/types.js'
+
+const simpleOptions = {
+  projectName: 'test',
+  targetDir: '/test',
+  framework: {
+    id: 'test',
+    name: 'Test',
+  },
+  chosenAddOns: [],
+  packageManager: 'pnpm',
+  typescript: true,
+  tailwind: true,
+  mode: 'file-router',
+  addOnOptions: {},
+} as unknown as Options
+
+describe('Filename Processing - Prefix Stripping', () => {
+  it('should strip single prefix from filename', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: { database: 'postgres' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './__postgres__testAddon.config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "postgres") { ignoreFile() } %>\n// PostgreSQL config\nexport default { driver: "postgres" }'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped
+    expect(output.files['/test/testAddon.config.ts']).toBeDefined()
+    expect(output.files['/test/testAddon.config.ts'].trim()).toEqual('// PostgreSQL config\nexport default { driver: \'postgres\' }')
+    
+    // Original prefixed filename should not exist
+    expect(output.files['/test/__postgres__testAddon.config.ts']).toBeUndefined()
+  })
+
+  it('should strip prefix from nested directory paths', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: { database: 'mysql' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './src/db/__mysql__connection.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "mysql") { ignoreFile() } %>\n// MySQL connection\nexport const connection = "mysql"'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped, preserving directory structure
+    expect(output.files['/test/src/db/connection.ts']).toBeDefined()
+    expect(output.files['/test/src/db/connection.ts'].trim()).toEqual('// MySQL connection\nexport const connection = \'mysql\'')
+    
+    // Original prefixed path should not exist
+    expect(output.files['/test/src/db/__mysql__connection.ts']).toBeUndefined()
+  })
+
+  it('should handle multiple prefixed files in same directory', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: { database: 'sqlite' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './__postgres__testAddon.config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "postgres") { ignoreFile() } %>\n// PostgreSQL config'
+    )
+    await templateFile(
+      './__mysql__testAddon.config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "mysql") { ignoreFile() } %>\n// MySQL config'
+    )
+    await templateFile(
+      './__sqlite__testAddon.config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "sqlite") { ignoreFile() } %>\n// SQLite config'
+    )
+    environment.finishRun()
+
+    // Only SQLite file should exist (others ignored via ignoreFile())
+    expect(output.files['/test/testAddon.config.ts']).toBeDefined()
+    expect(output.files['/test/testAddon.config.ts'].trim()).toEqual('// SQLite config')
+    
+    // Prefixed filenames should not exist
+    expect(output.files['/test/__postgres__testAddon.config.ts']).toBeUndefined()
+    expect(output.files['/test/__mysql__testAddon.config.ts']).toBeUndefined()
+    expect(output.files['/test/__sqlite__testAddon.config.ts']).toBeUndefined()
+  })
+
+  it('should handle complex filename patterns', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        auth: { provider: 'auth0' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './__auth0__auth.config.js.ejs',
+      '<% if (addOnOption.auth.provider !== "auth0") { ignoreFile() } %>\n// Auth0 configuration\nmodule.exports = { provider: "auth0" }'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped
+    expect(output.files['/test/auth.config.js']).toBeDefined()
+    expect(output.files['/test/auth.config.js'].trim()).toEqual('// Auth0 configuration\nmodule.exports = { provider: "auth0" }')
+  })
+
+  it('should handle prefixed files with .append.ejs extension', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: { database: 'postgres' }
+      }
+    })
+    environment.startRun()
+    // Create base file first
+    await templateFile(
+      './.env.ejs',
+      'BASE_VAR=value\n'
+    )
+    // Then append with prefixed filename
+    await templateFile(
+      './__postgres__.env.append.ejs',
+      '<% if (addOnOption.testAddon.database !== "postgres") { ignoreFile() } %>\nDATABASE_URL=postgresql://localhost:5432/mydb\n'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped and content appended
+    expect(output.files['/test/.env']).toBeDefined()
+    expect(output.files['/test/.env']).toEqual('BASE_VAR=value\n\nDATABASE_URL=postgresql://localhost:5432/mydb\n')
+  })
+
+  it('should handle files without prefixes normally', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions)
+    environment.startRun()
+    await templateFile(
+      './regular-file.ts.ejs',
+      'export const config = "normal"'
+    )
+    environment.finishRun()
+
+    // File should be created with normal filename processing
+    expect(output.files['/test/regular-file.ts']).toBeDefined()
+    expect(output.files['/test/regular-file.ts']).toEqual('export const config = \'normal\'\n')
+  })
+
+  it('should handle malformed prefixes gracefully', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions)
+    environment.startRun()
+    await templateFile(
+      './__malformed_prefix.ts.ejs',
+      'export const config = "malformed"'
+    )
+    await templateFile(
+      './__only_one_underscore.ts.ejs',
+      'export const config = "malformed2"'
+    )
+    await templateFile(
+      './____.ts.ejs',
+      'export const config = "empty"'
+    )
+    environment.finishRun()
+
+    // Files with malformed prefixes should be created as-is (minus .ejs extension)
+    expect(output.files['/test/__malformed_prefix.ts']).toBeDefined()
+    expect(output.files['/test/__only_one_underscore.ts']).toBeDefined()
+    expect(output.files['/test/____.ts']).toBeDefined()
+  })
+
+  it('should handle deeply nested prefixed files', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        styling: { framework: 'tailwind' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './src/styles/components/__tailwind__button.css.ejs',
+      '<% if (addOnOption.styling.framework !== "tailwind") { ignoreFile() } %>\n@tailwind base;\n@tailwind components;\n@tailwind utilities;'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped, preserving deep directory structure
+    expect(output.files['/test/src/styles/components/button.css']).toBeDefined()
+    expect(output.files['/test/src/styles/components/button.css'].trim()).toEqual('@tailwind base;\n@tailwind components;\n@tailwind utilities;')
+  })
+
+  it('should handle prefix stripping with different option values', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        ui: { library: 'chakra' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './__chakra__theme.ts.ejs',
+      '<% if (addOnOption.ui.library !== "chakra") { ignoreFile() } %>\n// Chakra UI theme\nexport const theme = { colors: {} }'
+    )
+    await templateFile(
+      './__mui__theme.ts.ejs',
+      '<% if (addOnOption.ui.library !== "mui") { ignoreFile() } %>\n// Material-UI theme\nexport const theme = { palette: {} }'
+    )
+    environment.finishRun()
+
+    // Only Chakra file should exist (MUI ignored via ignoreFile())
+    expect(output.files['/test/theme.ts']).toBeDefined()
+    expect(output.files['/test/theme.ts'].trim()).toEqual('// Chakra UI theme\nexport const theme = { colors: {} }')
+    
+    // Prefixed filenames should not exist
+    expect(output.files['/test/__chakra__theme.ts']).toBeUndefined()
+    expect(output.files['/test/__mui__theme.ts']).toBeUndefined()
+  })
+
+  it('should handle complex prefix with special characters', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        deployment: { platform: 'vercel-edge' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './__vercel-edge__api.ts.ejs',
+      '<% if (addOnOption.deployment.platform !== "vercel-edge") { ignoreFile() } %>\n// Vercel Edge API\nexport const runtime = "edge"'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped
+    expect(output.files['/test/api.ts']).toBeDefined()
+    expect(output.files['/test/api.ts'].trim()).toEqual('// Vercel Edge API\nexport const runtime = \'edge\'')
+  })
+
+  it('should handle multiple prefixes in same filename (edge case)', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        test: { value: 'postgres' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './__postgres__file__with__underscores.ts.ejs',
+      '<% if (addOnOption.test.value !== "postgres") { ignoreFile() } %>\n// File with underscores\nexport const value = "test"'
+    )
+    environment.finishRun()
+
+    // Should only strip the first valid prefix pattern
+    expect(output.files['/test/file__with__underscores.ts']).toBeDefined()
+    expect(output.files['/test/file__with__underscores.ts'].trim()).toEqual('// File with underscores\nexport const value = \'test\'')
+  })
+})