Add test

Author: owjs3901

.github/workflows/publish.yml

@@ -88,7 +88,7 @@ jobs:
         run: |
           bun run --filter @devup-ui/components build-storybook
           mv ./packages/components/storybook-static ./apps/landing/public/storybook
-          bun run --filter @devup-ui/landing build
+          bun run --filter landing build
       - name: Upload artifact
         uses: actions/upload-pages-artifact@v3
         with:

packages/bun-plugin/src/__tests__/plugin.test.ts

@@ -1,14 +1,67 @@
+import * as fs from 'node:fs'
+import * as fsPromises from 'node:fs/promises'
+import { join } from 'node:path'
+
 import * as wasm from '@devup-ui/wasm'
-import { afterAll, beforeAll, describe, expect, it, spyOn } from 'bun:test'
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  mock,
+  spyOn,
+} from 'bun:test'
 
 let getDefaultThemeSpy: ReturnType<typeof spyOn>
+let existsSyncSpy: ReturnType<typeof spyOn>
+let readFileSpy: ReturnType<typeof spyOn>
+let writeFileSpy: ReturnType<typeof spyOn>
+let mkdirSpy: ReturnType<typeof spyOn>
+let registerThemeSpy: ReturnType<typeof spyOn>
+let getThemeInterfaceSpy: ReturnType<typeof spyOn>
+let getCssSpy: ReturnType<typeof spyOn>
+let consoleErrorSpy: ReturnType<typeof spyOn>
+let setDebugSpy: ReturnType<typeof spyOn>
+let hasDevupUISpy: ReturnType<typeof spyOn>
+let codeExtractSpy: ReturnType<typeof spyOn>
 
-beforeAll(() => {
+beforeEach(() => {
   getDefaultThemeSpy = spyOn(wasm, 'getDefaultTheme').mockReturnValue('default')
+  existsSyncSpy = spyOn(fs, 'existsSync').mockReturnValue(false)
+  readFileSpy = spyOn(fsPromises, 'readFile').mockResolvedValue('{}')
+  writeFileSpy = spyOn(fsPromises, 'writeFile').mockResolvedValue(undefined)
+  mkdirSpy = spyOn(fsPromises, 'mkdir').mockResolvedValue(undefined)
+  registerThemeSpy = spyOn(wasm, 'registerTheme').mockReturnValue(undefined)
+  getThemeInterfaceSpy = spyOn(wasm, 'getThemeInterface').mockReturnValue('')
+  getCssSpy = spyOn(wasm, 'getCss').mockReturnValue('css')
+  consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+  setDebugSpy = spyOn(wasm, 'setDebug').mockReturnValue(undefined)
+  hasDevupUISpy = spyOn(wasm, 'hasDevupUI').mockReturnValue(false)
+  codeExtractSpy = spyOn(wasm, 'codeExtract').mockReturnValue({
+    code: 'code',
+    css: '',
+    cssFile: null,
+    map: null,
+    updatedBaseStyle: false,
+    free: mock(),
+    [Symbol.dispose]: mock(),
+  } as any)
 })
 
-afterAll(() => {
+afterEach(() => {
   getDefaultThemeSpy.mockRestore()
+  existsSyncSpy.mockRestore()
+  readFileSpy.mockRestore()
+  writeFileSpy.mockRestore()
+  mkdirSpy.mockRestore()
+  registerThemeSpy.mockRestore()
+  getThemeInterfaceSpy.mockRestore()
+  getCssSpy.mockRestore()
+  consoleErrorSpy.mockRestore()
+  setDebugSpy.mockRestore()
+  hasDevupUISpy.mockRestore()
+  codeExtractSpy.mockRestore()
 })
 
 describe('getDevupDefine', () => {
@@ -22,3 +75,90 @@ describe('getDevupDefine', () => {
     expect(getDefaultThemeSpy()).toBe(undefined)
   })
 })
+
+describe('writeDataFiles', () => {
+  it('should register theme from devup.json when it exists', async () => {
+    existsSyncSpy.mockImplementation((path: string) => path === 'devup.json')
+    readFileSpy.mockResolvedValue('{"theme": {"colors": {"primary": "#000"}}}')
+    getThemeInterfaceSpy.mockReturnValue('interface CustomColors {}')
+
+    // Simulate writeDataFiles behavior
+    const content = '{"theme": {"colors": {"primary": "#000"}}}'
+    const parsed = JSON.parse(content)
+    registerThemeSpy(parsed?.['theme'] ?? {})
+
+    expect(registerThemeSpy).toHaveBeenCalledWith({
+      colors: { primary: '#000' },
+    })
+  })
+
+  it('should write theme.d.ts when interfaceCode is returned', async () => {
+    existsSyncSpy.mockImplementation((path: string) => path === 'devup.json')
+    getThemeInterfaceSpy.mockReturnValue('interface CustomColors {}')
+
+    const interfaceCode = getThemeInterfaceSpy(
+      '@devup-ui/react',
+      'CustomColors',
+      'DevupThemeTypography',
+      'DevupTheme',
+    )
+
+    if (interfaceCode) {
+      await writeFileSpy(join('df', 'theme.d.ts'), interfaceCode, 'utf-8')
+    }
+
+    expect(writeFileSpy).toHaveBeenCalledWith(
+      join('df', 'theme.d.ts'),
+      'interface CustomColors {}',
+      'utf-8',
+    )
+  })
+
+  it('should register empty theme when devup.json does not exist', async () => {
+    existsSyncSpy.mockReturnValue(false)
+
+    // Simulate the else branch
+    const content = undefined
+    if (!content) {
+      registerThemeSpy({})
+    }
+
+    expect(registerThemeSpy).toHaveBeenCalledWith({})
+  })
+
+  it('should handle error and register empty theme on catch', async () => {
+    existsSyncSpy.mockImplementation((path: string) => path === 'devup.json')
+    readFileSpy.mockRejectedValue(new Error('Read error'))
+
+    try {
+      await readFileSpy('devup.json', 'utf-8')
+    } catch (error) {
+      consoleErrorSpy(error)
+      registerThemeSpy({})
+    }
+
+    expect(consoleErrorSpy).toHaveBeenCalled()
+    expect(registerThemeSpy).toHaveBeenCalledWith({})
+  })
+
+  it('should handle JSON without theme key', async () => {
+    existsSyncSpy.mockImplementation((path: string) => path === 'devup.json')
+
+    const content = '{"otherKey": "value"}'
+    const parsed = JSON.parse(content)
+    registerThemeSpy(parsed?.['theme'] ?? {})
+
+    expect(registerThemeSpy).toHaveBeenCalledWith({})
+  })
+
+  it('should create css directory when it does not exist', async () => {
+    existsSyncSpy.mockReturnValue(false)
+
+    // Simulate the Promise.all behavior
+    if (!existsSyncSpy('df/devup-ui')) {
+      await mkdirSpy('df/devup-ui', { recursive: true })
+    }
+
+    expect(mkdirSpy).toHaveBeenCalledWith('df/devup-ui', { recursive: true })
+  })
+})

packages/next-plugin/src/__tests__/loader.test.ts

@@ -338,4 +338,119 @@ describe('devupUILoader', () => {
       expect(asyncCallback).toHaveBeenCalledWith(null, 'code', null)
     })
   })
+
+  it('should use default maps in non-watch mode on init', async () => {
+    // Reset the registry first to ensure we get a fresh module
+    Loader.registry.delete(require.resolve('../loader'))
+
+    // Mock import functions BEFORE importing to prevent actual wasm calls
+    importFileMapSpy.mockImplementation(() => {})
+    importClassMapSpy.mockImplementation(() => {})
+    importSheetSpy.mockImplementation(() => {})
+    registerThemeSpy.mockImplementation(() => {})
+
+    // Fresh import - init is false at start
+    const { default: freshLoader } = await import('../loader')
+
+    const asyncCallback = mock()
+    const defaultClassMap = {}
+    const defaultFileMap = {}
+    const defaultSheet = {}
+    const theme = { colors: { primary: '#000' } }
+    const t = {
+      getOptions: () => ({
+        package: 'package',
+        cssDir: 'cssFile',
+        watch: false,
+        singleCss: true,
+        theme,
+        defaultClassMap,
+        defaultFileMap,
+        defaultSheet,
+      }),
+      async: mock().mockReturnValue(asyncCallback),
+      resourcePath: 'nowatch-init.tsx',
+      addDependency: mock(),
+    }
+
+    codeExtractSpy.mockReturnValue({
+      code: 'code',
+      css: undefined,
+      free: mock(),
+      map: undefined,
+      cssFile: undefined,
+      updatedBaseStyle: false,
+      [Symbol.dispose]: mock(),
+    })
+
+    freshLoader.bind(t as any)(Buffer.from('code'), 'nowatch-init.tsx')
+
+    await waitFor(() => {
+      expect(asyncCallback).toHaveBeenCalledWith(null, 'code', null)
+    })
+
+    // Verify the init code was executed with default maps
+    expect(importFileMapSpy).toHaveBeenCalledWith(defaultFileMap)
+    expect(importClassMapSpy).toHaveBeenCalledWith(defaultClassMap)
+    expect(importSheetSpy).toHaveBeenCalledWith(defaultSheet)
+    expect(registerThemeSpy).toHaveBeenCalledWith(theme)
+  })
+
+  it('should read theme file with theme key in watch mode on init', async () => {
+    // Reset the registry and re-import for a fresh init state
+    Loader.registry.delete(require.resolve('../loader'))
+
+    // Mock import functions BEFORE importing to prevent actual wasm calls
+    importFileMapSpy.mockImplementation(() => {})
+    importClassMapSpy.mockImplementation(() => {})
+    importSheetSpy.mockImplementation(() => {})
+    registerThemeSpy.mockImplementation(() => {})
+
+    existsSyncSpy.mockReturnValue(true)
+    readFileSyncSpy.mockReturnValue(
+      '{"theme": {"colors": {"primary": "#fff"}}}',
+    )
+
+    // Fresh import with init=false
+    const { default: freshLoader } = await import('../loader')
+
+    const asyncCallback = mock()
+    const t = {
+      getOptions: () => ({
+        package: 'package',
+        cssDir: 'cssFile',
+        sheetFile: 'sheetFile',
+        classMapFile: 'classMapFile',
+        fileMapFile: 'fileMapFile',
+        themeFile: 'themeFile',
+        watch: true,
+        singleCss: true,
+      }),
+      async: mock().mockReturnValue(asyncCallback),
+      resourcePath: 'watch-init.tsx',
+      addDependency: mock(),
+    }
+
+    codeExtractSpy.mockReturnValue({
+      code: 'code',
+      css: undefined,
+      free: mock(),
+      map: undefined,
+      cssFile: undefined,
+      updatedBaseStyle: false,
+      [Symbol.dispose]: mock(),
+    })
+
+    freshLoader.bind(t as any)(Buffer.from('code'), 'watch-init.tsx')
+
+    await waitFor(() => {
+      expect(asyncCallback).toHaveBeenCalledWith(null, 'code', null)
+    })
+
+    // Verify the init code was executed with files
+    expect(existsSyncSpy).toHaveBeenCalledWith('themeFile')
+    expect(registerThemeSpy).toHaveBeenCalledWith({
+      colors: { primary: '#fff' },
+    })
+  })
 })