@ronaldphilipsen/local-action 0.0.0-stage → 7.0.1

package/__tests__/stubs/core/path-utils.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals'
+import path from 'path'
+import { ResetCoreMetadata } from '../../../src/stubs/core/core.js'
+import {
+  toPlatformPath,
+  toPosixPath,
+  toWin32Path
+} from '../../../src/stubs/core/path-utils.js'
+import { ResetEnvMetadata } from '../../../src/stubs/env.js'
+
+// Prevent output during tests
+jest.spyOn(console, 'log').mockImplementation(() => {})
+jest.spyOn(console, 'table').mockImplementation(() => {})
+
+describe('path-utils', () => {
+  beforeEach(() => {
+    // Reset metadata
+    ResetEnvMetadata()
+    ResetCoreMetadata()
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  describe('toWin32Path()', () => {
+    it('Returns a WIN32 path', () => {
+      expect(toWin32Path('C:/Users/mona/Desktop')).toEqual(
+        'C:\\Users\\mona\\Desktop'
+      )
+    })
+  })
+
+  describe('toPlatformPath()', () => {
+    it('Returns a platform-specific path', () => {
+      expect(toPlatformPath('C:/Users/mona/Desktop')).toEqual(
+        `C:${path.sep}Users${path.sep}mona${path.sep}Desktop`
+      )
+
+      expect(toPosixPath('C:\\Users\\mona\\Desktop')).toEqual(
+        `C:${path.sep}Users${path.sep}mona${path.sep}Desktop`
+      )
+    })
+  })
+})

package/__tests__/stubs/core/platform.test.ts

@@ -0,0 +1,89 @@
+import { jest } from '@jest/globals'
+import * as exec from '../../../__fixtures__/@actions/exec.js'
+
+jest.unstable_mockModule('@actions/exec', () => exec)
+
+const platform = await import('../../../src/stubs/core/platform.js')
+
+describe('platform', () => {
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  describe('getWindowsInfo', () => {
+    it('Gets Windows OS info', async () => {
+      exec.getExecOutput
+        .mockResolvedValueOnce({
+          stdout: '10',
+          stderr: '',
+          exitCode: 0
+        } as never)
+        .mockResolvedValueOnce({
+          stdout: 'Microsoft Windows 10 Pro',
+          stderr: '',
+          exitCode: 0
+        } as never)
+
+      const result = await platform.getWindowsInfo()
+
+      expect(exec.getExecOutput).toHaveBeenCalledTimes(2)
+      expect(result).toMatchObject({
+        name: 'Microsoft Windows 10 Pro',
+        version: '10'
+      })
+    })
+  })
+
+  describe('getMacOsInfo', () => {
+    it('Gets macOS info', async () => {
+      exec.getExecOutput.mockResolvedValueOnce({
+        stdout:
+          'ProductName:    macOS\nProductVersion: 13.0.1\nBuildVersion:   22A400',
+        stderr: '',
+        exitCode: 0
+      } as never)
+
+      const result = await platform.getMacOsInfo()
+
+      expect(exec.getExecOutput).toHaveBeenCalledTimes(1)
+      expect(result).toMatchObject({
+        name: 'macOS',
+        version: '13.0.1'
+      })
+    })
+
+    it('Gets macOS info (defaults to empty strings)', async () => {
+      exec.getExecOutput.mockResolvedValueOnce({
+        stdout: '',
+        stderr: '',
+        exitCode: 0
+      } as never)
+
+      const result = await platform.getMacOsInfo()
+
+      expect(exec.getExecOutput).toHaveBeenCalledTimes(1)
+      expect(result).toMatchObject({
+        name: '',
+        version: ''
+      })
+    })
+  })
+
+  describe('getLinuxInfo', () => {
+    it('Gets Linux OS info', async () => {
+      exec.getExecOutput.mockResolvedValueOnce({
+        stdout: 'Linux\nMint',
+        stderr: '',
+        exitCode: 0
+      } as never)
+
+      const result = await platform.getLinuxInfo()
+
+      expect(exec.getExecOutput).toHaveBeenCalledTimes(1)
+      expect(result).toMatchObject({
+        name: 'Linux',
+        version: 'Mint'
+      })
+    })
+  })
+})

package/__tests__/stubs/core/summary.test.ts

@@ -0,0 +1,455 @@
+import { jest } from '@jest/globals'
+import fs from 'fs'
+import { EOL } from 'os'
+import path from 'path'
+import { CoreMeta, ResetCoreMetadata } from '../../../src/stubs/core/core.js'
+import { Summary } from '../../../src/stubs/core/summary.js'
+
+let summary: Summary = new Summary()
+
+// Prevent output during tests
+jest.spyOn(console, 'log').mockImplementation(() => {})
+
+describe('Summary', () => {
+  beforeEach(() => {
+    // Reset the summary instance
+    summary = new Summary()
+
+    CoreMeta.stepSummaryPath = 'summary.md'
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+
+    // Restore environment metadata
+    ResetCoreMetadata()
+  })
+
+  describe('constructor', () => {
+    it('Creates an instance of the Summary class', () => {
+      expect(summary).toBeInstanceOf(Summary)
+    })
+  })
+
+  describe('filePath()', () => {
+    let fs_accessSyncSpy: jest.SpiedFunction<typeof fs.accessSync>
+    let fs_existsSyncSpy: jest.SpiedFunction<typeof fs.existsSync>
+    let path_resolveSpy: jest.SpiedFunction<typeof path.resolve>
+
+    beforeEach(() => {
+      fs_accessSyncSpy = jest
+        .spyOn(fs, 'accessSync')
+        .mockImplementation(() => {})
+      fs_existsSyncSpy = jest.spyOn(fs, 'existsSync').mockReturnValue(true)
+      path_resolveSpy = jest
+        .spyOn(path, 'resolve')
+        .mockReturnValueOnce('/path/to/summary.md')
+    })
+
+    afterEach(() => {
+      fs_accessSyncSpy.mockRestore()
+      fs_existsSyncSpy.mockRestore()
+      path_resolveSpy.mockRestore()
+    })
+
+    it('Resolves the summary file path from the environment', async () => {
+      await expect(summary.filePath()).resolves.toBe('/path/to/summary.md')
+
+      expect(fs_accessSyncSpy).toHaveBeenCalledWith(
+        '/path/to/summary.md',
+        fs.constants.R_OK | fs.constants.W_OK
+      )
+    })
+
+    it('Returns the already-resolved file path', async () => {
+      await summary.filePath()
+      await summary.filePath()
+      await summary.filePath()
+
+      expect(fs_accessSyncSpy).toHaveBeenCalledTimes(1)
+      expect(fs_accessSyncSpy).toHaveBeenNthCalledWith(
+        1,
+        '/path/to/summary.md',
+        fs.constants.R_OK | fs.constants.W_OK
+      )
+
+      await expect(summary.filePath()).resolves.toBe('/path/to/summary.md')
+    })
+
+    it('Throws an error if the environment variable is not set', async () => {
+      CoreMeta.stepSummaryPath = ''
+
+      await expect(summary.filePath()).rejects.toThrow(
+        'Unable to find environment variable for $GITHUB_STEP_SUMMARY. Check if your runtime environment supports job summaries.'
+      )
+    })
+
+    it('Throws an error if the file does not exist', async () => {
+      fs_accessSyncSpy.mockReset().mockImplementation(() => {
+        throw new Error('File does not exist')
+      })
+
+      await expect(summary.filePath()).rejects.toThrow(
+        `Unable to access summary file: '/path/to/summary.md'. Check if the file has correct read/write permissions.`
+      )
+    })
+  })
+
+  describe('wrap()', () => {
+    it('Wraps the input string with the provided tag', () => {
+      expect(summary.wrap('div', 'text')).toBe('<div>text</div>')
+    })
+
+    it('Creates a self-closing tag when no input string is provided', () => {
+      expect(summary.wrap('img', null)).toBe('<img>')
+    })
+
+    it('Adds HTML attributes', () => {
+      expect(
+        summary.wrap('a', 'GitHub.com', {
+          href: 'https://github.com',
+          target: '_blank'
+        })
+      ).toBe('<a href="https://github.com" target="_blank">GitHub.com</a>')
+    })
+  })
+
+  describe('write()', () => {
+    let fs_accessSyncSpy: jest.SpiedFunction<typeof fs.accessSync>
+    let fs_appendFileSyncSpy: jest.SpiedFunction<typeof fs.appendFileSync>
+    let fs_existsSyncSpy: jest.SpiedFunction<typeof fs.existsSync>
+    let fs_writeFileSyncSpy: jest.SpiedFunction<typeof fs.writeFileSync>
+    let path_resolveSpy: jest.SpiedFunction<typeof path.resolve>
+
+    beforeEach(() => {
+      fs_accessSyncSpy = jest
+        .spyOn(fs, 'accessSync')
+        .mockImplementation(() => {})
+      fs_appendFileSyncSpy = jest
+        .spyOn(fs, 'appendFileSync')
+        .mockImplementation(() => {})
+      fs_existsSyncSpy = jest.spyOn(fs, 'existsSync').mockReturnValueOnce(true)
+      fs_writeFileSyncSpy = jest
+        .spyOn(fs, 'writeFileSync')
+        .mockImplementation(() => {})
+      path_resolveSpy = jest
+        .spyOn(path, 'resolve')
+        .mockReturnValueOnce('/path/to/summary.md')
+
+      // Add some text to test with
+      summary.addRaw('text')
+    })
+
+    afterEach(() => {
+      fs_accessSyncSpy.mockRestore()
+      fs_appendFileSyncSpy.mockRestore()
+      fs_existsSyncSpy.mockRestore()
+      fs_writeFileSyncSpy.mockRestore()
+      path_resolveSpy.mockRestore()
+
+      // Clear the buffer for the next test
+      summary.emptyBuffer()
+    })
+
+    it('Appends content to the summary file', async () => {
+      await summary.write()
+
+      expect(fs_existsSyncSpy).toHaveBeenCalledWith('/path/to/summary.md')
+      expect(fs_writeFileSyncSpy).not.toHaveBeenCalled()
+      expect(fs_appendFileSyncSpy).toHaveBeenCalledWith(
+        '/path/to/summary.md',
+        'text',
+        { encoding: 'utf8' }
+      )
+    })
+
+    it('Creates the summary file if it does not exist', async () => {
+      fs_existsSyncSpy.mockReset().mockReturnValueOnce(false)
+
+      await summary.write()
+
+      expect(fs_existsSyncSpy).toHaveBeenCalledWith('/path/to/summary.md')
+      expect(fs_writeFileSyncSpy).toHaveBeenCalledWith(
+        '/path/to/summary.md',
+        '',
+        { encoding: 'utf8' }
+      )
+      expect(fs_appendFileSyncSpy).toHaveBeenCalledWith(
+        '/path/to/summary.md',
+        'text',
+        { encoding: 'utf8' }
+      )
+    })
+
+    it('Overwrites the summary file', async () => {
+      await summary.write({ overwrite: true })
+
+      expect(fs_existsSyncSpy).toHaveBeenCalledWith('/path/to/summary.md')
+      expect(fs_writeFileSyncSpy).toHaveBeenCalledWith(
+        '/path/to/summary.md',
+        'text',
+        { encoding: 'utf8' }
+      )
+      expect(fs_appendFileSyncSpy).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('clear()', () => {
+    it('Clears the buffer', async () => {
+      const summary_emptyBufferSpy = jest
+        .spyOn(summary, 'emptyBuffer')
+        .mockReturnValue(summary)
+      const summary_writeSpy = jest
+        .spyOn(summary, 'write')
+        .mockResolvedValue(summary)
+
+      await summary.clear()
+
+      expect(summary_emptyBufferSpy).toHaveBeenCalled()
+      expect(summary_writeSpy).toHaveBeenCalled()
+    })
+  })
+
+  describe('stringify()', () => {
+    it('Returns the buffer', () => {
+      summary.addRaw('text')
+
+      expect(summary.stringify()).toEqual('text')
+    })
+  })
+
+  describe('isEmptyBuffer()', () => {
+    it('Returns true if the buffer is empty', () => {
+      expect(summary.isEmptyBuffer()).toBe(true)
+    })
+
+    it('Returns false if the buffer is not empty', () => {
+      summary.addRaw('text')
+
+      expect(summary.isEmptyBuffer()).toBe(false)
+    })
+  })
+
+  describe('emptyBuffer()', () => {
+    it('Empties the buffer', () => {
+      summary.addRaw('text')
+      summary.emptyBuffer()
+
+      expect(summary.isEmptyBuffer()).toBe(true)
+      expect(summary.stringify()).toEqual('')
+    })
+  })
+
+  describe('addRaw()', () => {
+    it('Adds text', () => {
+      summary.addRaw('text')
+
+      expect(summary.stringify()).toEqual('text')
+    })
+
+    it('Adds an EOL', () => {
+      const summary_addEOLSpy = jest
+        .spyOn(summary, 'addEOL')
+        .mockReturnValue(summary)
+
+      summary.addRaw('text', true)
+
+      expect(summary.stringify()).toEqual('text')
+      expect(summary_addEOLSpy).toHaveBeenCalled()
+    })
+  })
+
+  describe('addEOL()', () => {
+    it('Adds an EOL', () => {
+      const summary_addRawSpy = jest
+        .spyOn(summary, 'addRaw')
+        .mockReturnValue(summary)
+
+      summary.addEOL()
+
+      expect(summary_addRawSpy).toHaveBeenCalledWith(EOL)
+    })
+  })
+
+  describe('addCodeBlock()', () => {
+    it('Adds a code block', () => {
+      summary.addCodeBlock('text')
+
+      expect(summary.stringify() === `<pre><code>text</code></pre>${EOL}`).toBe(
+        true
+      )
+    })
+
+    it('Adds a code block with syntax highlighting', () => {
+      summary.addCodeBlock('text', 'javascript')
+
+      expect(
+        summary.stringify() ===
+          `<pre lang="javascript"><code>text</code></pre>${EOL}`
+      ).toBe(true)
+    })
+  })
+
+  describe('addList()', () => {
+    it('Adds an unordered list', () => {
+      summary.addList(['text', 'text'])
+
+      expect(
+        summary.stringify() === `<ul><li>text</li><li>text</li></ul>${EOL}`
+      ).toBe(true)
+    })
+
+    it('Adds an ordered list', () => {
+      summary.addList(['text', 'text'], true)
+
+      expect(
+        summary.stringify() === `<ol><li>text</li><li>text</li></ol>${EOL}`
+      ).toBe(true)
+    })
+  })
+
+  describe('addTable()', () => {
+    it('Adds a table', () => {
+      summary.addTable([
+        [
+          {
+            data: 'text',
+            header: true,
+            colspan: '1',
+            rowspan: '1'
+          },
+          {
+            data: 'text',
+            header: true,
+            colspan: '1',
+            rowspan: '1'
+          },
+          {
+            data: 'text',
+            header: true
+          }
+        ],
+        [
+          {
+            data: 'text'
+          },
+          'text',
+          'text'
+        ]
+      ])
+
+      expect(
+        summary.stringify() ===
+          `<table><tr><th colspan="1" rowspan="1">text</th><th colspan="1" rowspan="1">text</th><th>text</th></tr><tr><td>text</td><td>text</td><td>text</td></tr></table>${EOL}`
+      ).toBe(true)
+    })
+  })
+
+  describe('addDetails()', () => {
+    it('Adds a details element', () => {
+      summary.addDetails('label', 'text')
+
+      expect(
+        summary.stringify() ===
+          `<details><summary>label</summary>text</details>${EOL}`
+      ).toBe(true)
+    })
+  })
+
+  describe('addImage()', () => {
+    it('Adds an image', () => {
+      summary.addImage('src', 'alt')
+
+      expect(summary.stringify() === `<img src="src" alt="alt">${EOL}`).toBe(
+        true
+      )
+    })
+
+    it('Adds an image with options', () => {
+      summary.addImage('src', 'alt', {
+        width: '100',
+        height: '100'
+      })
+
+      expect(
+        summary.stringify() ===
+          `<img src="src" alt="alt" width="100" height="100">${EOL}`
+      ).toBe(true)
+    })
+  })
+
+  describe('addHeading()', () => {
+    it('Adds a heading (no level)', () => {
+      summary.addHeading('text')
+
+      expect(summary.stringify() === `<h1>text</h1>${EOL}`).toBe(true)
+    })
+
+    it('Adds a heading (number level)', () => {
+      summary.addHeading('text', 2)
+
+      expect(summary.stringify() === `<h2>text</h2>${EOL}`).toBe(true)
+    })
+
+    it('Adds a heading (string level)', () => {
+      summary.addHeading('text', '3')
+
+      expect(summary.stringify() === `<h3>text</h3>${EOL}`).toBe(true)
+    })
+
+    it('Adds a heading (out of bounds level)', () => {
+      summary.addHeading('text', -10)
+
+      expect(summary.stringify() === `<h1>text</h1>${EOL}`).toBe(true)
+    })
+
+    it('Adds a heading (NaN level)', () => {
+      summary.addHeading('text', 'text')
+
+      expect(summary.stringify() === `<h1>text</h1>${EOL}`).toBe(true)
+    })
+  })
+
+  describe('addSeparator()', () => {
+    it('Adds a horizontal rule', () => {
+      summary.addSeparator()
+
+      expect(summary.stringify() === `<hr>${EOL}`).toBe(true)
+    })
+  })
+
+  describe('addBreak()', () => {
+    it('Adds a line break', () => {
+      summary.addBreak()
+
+      expect(summary.stringify() === `<br>${EOL}`).toBe(true)
+    })
+  })
+
+  describe('addQuote()', () => {
+    it('Adds a quote', () => {
+      summary.addQuote('text')
+
+      expect(
+        summary.stringify() === `<blockquote>text</blockquote>${EOL}`
+      ).toBe(true)
+    })
+
+    it('Adds a quote with citation', () => {
+      summary.addQuote('text', 'citation')
+
+      expect(
+        summary.stringify() ===
+          `<blockquote cite="citation">text</blockquote>${EOL}`
+      ).toBe(true)
+    })
+  })
+
+  describe('addLink()', () => {
+    it('Adds a link', () => {
+      summary.addLink('text', 'url')
+
+      expect(summary.stringify() === `<a href="url">text</a>${EOL}`).toBe(true)
+    })
+  })
+})

package/__tests__/stubs/env.test.ts

@@ -0,0 +1,72 @@
+import { jest } from '@jest/globals'
+import { ResetCoreMetadata } from '../../src/stubs/core/core.js'
+import { EnvMeta, ResetEnvMetadata } from '../../src/stubs/env.js'
+import type { EnvMetadata } from '../../src/types.js'
+
+/** Empty EnvMetadata Object */
+const empty: EnvMetadata = {
+  actionFile: '',
+  actionPath: '',
+  artifacts: [],
+  caches: {},
+  dotenvFile: '',
+  entrypoint: '',
+  env: {},
+  inputs: {},
+  outputs: {},
+  path: '',
+  preEntrypoint: undefined,
+  postEntrypoint: undefined
+}
+
+// Prevent output during tests
+jest.spyOn(console, 'log').mockImplementation(() => {})
+
+describe('Env', () => {
+  beforeEach(() => {
+    // Reset metadata
+    ResetEnvMetadata()
+    ResetCoreMetadata()
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  describe('EnvMeta', () => {
+    it('Tracks updates to the environment metadata', () => {
+      // Initial state should be empty
+      expect(EnvMeta).toMatchObject(empty)
+
+      // Update the metadata
+      EnvMeta.actionFile = 'action.yml'
+      EnvMeta.actionPath = '/some/path'
+      EnvMeta.artifacts = [{ id: 1, name: 'test', size: 0 }]
+      EnvMeta.dotenvFile = '.env'
+      EnvMeta.entrypoint = 'main.ts'
+      EnvMeta.env = { TEST: 'test' }
+      EnvMeta.inputs = { input: { description: 'test input' } }
+      EnvMeta.outputs = { output: { description: 'test output' } }
+      EnvMeta.path = '/usr/bin'
+
+      // Verify the updated metadata
+      expect(EnvMeta).toMatchObject({
+        actionFile: 'action.yml',
+        actionPath: '/some/path',
+        artifacts: [{ id: 1, name: 'test', size: 0 }],
+        dotenvFile: '.env',
+        entrypoint: 'main.ts',
+        env: { TEST: 'test' },
+        inputs: { input: { description: 'test input' } },
+        outputs: { output: { description: 'test output' } },
+        path: '/usr/bin'
+      })
+
+      // Reset the metadata
+      ResetEnvMetadata()
+
+      // Verify the reset metadata
+      expect(EnvMeta).toMatchObject(empty)
+    })
+  })
+})