cddl2ts 0.3.0 → 0.4.0

package/tests/complex_types.test.ts

@@ -0,0 +1,54 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const complexTypesCDDL = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'complex_types.cddl')
+
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'cddl2ts',
+        version: '0.0.0'
+    }
+}))
+
+describe('complex types (Map, Set, RegExp, Date...)', () => {
+    let exitOrig = process.exit
+    let logOrig = console.log
+    let errorOrig = console.error
+
+    beforeEach(() => {
+        process.exit = vi.fn() as any
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+
+    it('should include all types in the union', async () => {
+        await cli([complexTypesCDDL, '--unknown-as-any'])
+
+        expect(process.exit).not.toHaveBeenCalledWith(1)
+        expect(console.error).not.toHaveBeenCalled()
+        expect(console.log).toHaveBeenCalled()
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+
+        // Check if all types are present in the union or defined
+        expect(output).toContain('ArrayLocalValue')
+        expect(output).toContain('DateLocalValue')
+        expect(output).toContain('MapLocalValue')
+        expect(output).toContain('ObjectLocalValue')
+        expect(output).toContain('RegExpLocalValue')
+        expect(output).toContain('SetLocalValue')
+
+        // Specific check for the buggy union generation where types were dropped
+        expect(output).toContain('export type LocalValue = ArrayLocalValue | DateLocalValue | MapLocalValue | ObjectLocalValue | RegExpLocalValue | SetLocalValue;')
+    })
+})

package/tests/group_choice.test.ts

@@ -0,0 +1,53 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const groupChoiceCDDL = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'group_choice.cddl')
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'cddl2ts',
+        version: '0.0.0'
+    }
+}))
+
+describe('group choice conversion', () => {
+    let exitOrig = process.exit
+    let logOrig = console.log
+    let errorOrig = console.error
+
+    beforeEach(() => {
+        process.exit = vi.fn() as any
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+
+    it('should generate a union type for multiple group choices', async () => {
+        await cli([groupChoiceCDDL, '--unknown-as-any'])
+
+        expect(process.exit).not.toHaveBeenCalledWith(1)
+        expect(console.error).not.toHaveBeenCalled()
+        expect(console.log).toHaveBeenCalled()
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+
+        // Verify it generates a union of all 3 types
+        expect(output).toContain('export type ProxyConfiguration = AutodetectProxyConfiguration | DirectProxyConfiguration | ManualProxyConfiguration')
+
+        // Verify interfaces are generated comfortably
+        // Note: As we now use Type Alias intersections for mixins instead of interfaces extends to support union mixins,
+        // these assertions are updated to expect type aliases.
+        expect(output).toContain('export type AutodetectProxyConfiguration = Extensible & {')
+        expect(output).toContain('export type DirectProxyConfiguration = Extensible & {')
+
+        expect(output).toMatchSnapshot()
+    })
+})

package/tests/literals.test.ts

@@ -0,0 +1,45 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const cddlFile = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'literals.cddl')
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'cddl2ts',
+        version: '0.0.0'
+    }
+}))
+
+describe('literals', () => {
+    let exitOrig = process.exit
+    let logOrig = console.log
+    let errorOrig = console.error
+
+    beforeEach(() => {
+        process.exit = vi.fn() as any
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+
+    it('should support bigint and null literals', async () => {
+        await cli([cddlFile])
+
+        expect(process.exit).not.toHaveBeenCalledWith(1)
+        expect(console.error).not.toHaveBeenCalled()
+
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+
+        // Assert output structure
+        expect(output).toMatchSnapshot()
+    })
+})

package/tests/mixin_union.test.ts

@@ -0,0 +1,56 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const cddlFile = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'mixin_union.cddl')
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'cddl2ts',
+        version: '0.0.0'
+    }
+}))
+
+describe('mixin union types', () => {
+    let exitOrig = process.exit
+    let logOrig = console.log
+    let errorOrig = console.error
+
+    beforeEach(() => {
+        process.exit = vi.fn() as any
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+
+    it('should generate union type aliases for mixin choices', async () => {
+        await cli([cddlFile])
+
+        expect(process.exit).not.toHaveBeenCalledWith(1)
+        expect(console.error).not.toHaveBeenCalled()
+
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+
+        // Check if Mixins is parsed correctly (intersection)
+        expect(output).toContain('export type Mixins = MixinA & MixinB')
+
+        // Check if UnionMixin is parsed correctly (single choice group)
+        // Group = (A / B) -> usually parsed as a choice of properties in the group
+
+        // More importantly for the queried code block:
+        // ComplexMixins = ((MixinA / MixinB), c: bool)
+        // This means it has a mixin that is a choice between MixinA and MixinB
+
+        // We expect something like:
+        // export type ComplexMixins = (MixinA | MixinB) & { c: boolean }
+        expect(output).toMatchSnapshot()
+    })
+})

package/tests/mod.test.ts

@@ -0,0 +1,74 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'foobar',
+        version: '1.2.3'
+    }
+}))
+
+describe('cddl2ts', () => {
+    const exitOrig = process.exit.bind(process)
+    const logOrig = console.log.bind(console)
+    const errorOrig = console.error.bind(console)
+    beforeEach(() => {
+        // @ts-expect-error
+        process.exit = vi.fn(() => {})
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    it('should print help if no args were provided', async () => {
+        await cli([])
+
+        expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/foobar/)) // Yargs showHelp() defaults to stderr
+        expect(process.exit).toHaveBeenCalledWith(0)
+    })
+
+    it('should print help --help is set in args', async () => {
+        await cli(['foo', 'bar', '--help', 'barfoo'])
+
+        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/foobar/))
+        expect(process.exit).toHaveBeenCalledWith(0)
+    })
+
+    it('should print version (alias)', async () => {
+        await cli(['foo', '-v', 'bar'])
+
+        expect(console.log).toHaveBeenCalledWith('1.2.3')
+        expect(process.exit).toHaveBeenCalledWith(0)
+    })
+
+    it('should print version (long flag)', async () => {
+        await cli(['foo', '--version', 'bar'])
+
+        expect(console.log).toHaveBeenCalledWith('1.2.3')
+        expect(process.exit).toHaveBeenCalledWith(0)
+    })
+
+    it('should fail if first parameter is not pointing to a file', async () => {
+        await cli(['foo'])
+
+        expect(console.error).toHaveBeenCalledTimes(1)
+        expect(process.exit).toHaveBeenCalledWith(1)
+    })
+
+    it('should generate correct types for test.cddl', async () => {
+        await cli([path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'test.cddl')])
+
+        expect(vi.mocked(console.log).mock.calls).toMatchSnapshot()
+        expect(process.exit).toHaveBeenCalledTimes(0)
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+})

package/tests/named_group_choice.test.ts

@@ -0,0 +1,47 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const cddlFile = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'named_group_choice.cddl')
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'cddl2ts',
+        version: '0.0.0'
+    }
+}))
+
+describe('named group choice', () => {
+    let exitOrig = process.exit
+    let logOrig = console.log
+    let errorOrig = console.error
+
+    beforeEach(() => {
+        process.exit = vi.fn() as any
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+
+    it('should generate a union type alias for named group references', async () => {
+        await cli([cddlFile])
+
+        expect(process.exit).not.toHaveBeenCalledWith(1)
+        expect(console.error).not.toHaveBeenCalled()
+
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+
+        // The export keyword is separated from the type definition by comments
+        expect(output).toMatch(/export\s+(\/\/.*\n)+\s*type Choice = OptionA \| OptionB/)
+        expect(output).toContain('export interface OptionA {')
+        expect(output).toContain('export interface OptionB {')
+    })
+})

package/tests/transform.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest'
+import { transform } from '../src/index.js'
+import type { Variable } from 'cddl'
+
+describe('literal transformation direct', () => {
+    it('should transform bigint literals correctly', () => {
+        const assignment: Variable = {
+            Type: 'variable',
+            Name: 'MyBigInt',
+            PropertyType: {
+                Type: 'literal',
+                Value: 9007199254740995n
+            } as any,
+            Comments: [],
+            IsChoiceAddition: false
+        }
+
+        const output = transform([assignment])
+        expect(output).toContain('export type MyBigInt = 9007199254740995n;')
+    })
+})

package/tests/unknown.test.ts

@@ -0,0 +1,51 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const localCDDL = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'unknown.cddl')
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'cddl2ts',
+        version: '0.0.0'
+    }
+}))
+
+describe('unknown option', () => {
+    let exitOrig = process.exit
+    let logOrig = console.log
+    let errorOrig = console.error
+
+    beforeEach(() => {
+        process.exit = vi.fn() as any
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+
+    it('should use unknown instead of any', async () => {
+        await cli([localCDDL, '--unknown-as-any'])
+
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+        expect(output).toContain('export type Foo = unknown;')
+        expect(output).toContain('export type Bar = unknown[];')
+        expect(output).toContain('export type Baz = Record<string, unknown>;')
+    })
+
+    it('should default to any', async () => {
+        await cli([localCDDL])
+
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+        expect(output).toContain('export type Foo = any;')
+        expect(output).toContain('export type Bar = any[];')
+        expect(output).toContain('export type Baz = Record<string, any>;')
+    })
+})

package/tests/webdriver_local.test.ts

@@ -0,0 +1,43 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const localCDDL = path.join(__dirname, '..', '..', '..', 'examples', 'webdriver', 'local.cddl')
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'cddl2ts',
+        version: '0.0.0'
+    }
+}))
+
+describe('webdriver examples', () => {
+    let exitOrig = process.exit
+    let logOrig = console.log
+    let errorOrig = console.error
+
+    beforeEach(() => {
+        process.exit = vi.fn() as any
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+
+    it('should generate types for local.cddl', async () => {
+        await cli([localCDDL, '--unknown-as-any'])
+
+        expect(process.exit).not.toHaveBeenCalledWith(1)
+        expect(console.error).not.toHaveBeenCalled()
+        expect(console.log).toHaveBeenCalled()
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+        expect(output).toMatchSnapshot()
+    })
+})

package/tests/webdriver_remote.test.ts

@@ -0,0 +1,43 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import cli from '../src/cli.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const remoteCDDL = path.join(__dirname, '..', '..', '..', 'examples', 'webdriver', 'remote.cddl')
+
+vi.mock('../src/constants', () => ({
+    pkg: {
+        name: 'cddl2ts',
+        version: '0.0.0'
+    }
+}))
+
+describe('webdriver examples', () => {
+    let exitOrig = process.exit
+    let logOrig = console.log
+    let errorOrig = console.error
+
+    beforeEach(() => {
+        process.exit = vi.fn() as any
+        console.log = vi.fn()
+        console.error = vi.fn()
+    })
+
+    afterEach(() => {
+        process.exit = exitOrig
+        console.log = logOrig
+        console.error = errorOrig
+    })
+
+    it('should generate types for remote.cddl', async () => {
+        await cli([remoteCDDL, '--unknown-as-any'])
+
+        expect(process.exit).not.toHaveBeenCalledWith(1)
+        expect(console.error).not.toHaveBeenCalled()
+        expect(console.log).toHaveBeenCalled()
+        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
+        expect(output).toMatchSnapshot()
+    })
+})

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig",
+  "compilerOptions": {
+    "outDir": "build",
+    "rootDir": "src",
+  },
+  "types": ["node"],
+  "include": [
+    "src/**/*",
+  ]
+}