cddl2py 0.0.1 → 0.1.1

package/tests/complex_types.test.ts

@@ -1,92 +0,0 @@
-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', 'complex_types.cddl')
-
-vi.mock('../src/constants', () => ({
-    pkg: {
-        name: 'cddl2py',
-        version: '0.1.0',
-        author: 'Test Author',
-        description: 'Generate Python types from CDDL'
-    },
-    NATIVE_TYPE_MAP: {
-        any: 'Any',
-        number: 'Union[int, float]',
-        int: 'int',
-        uint: 'int',
-        nint: 'int',
-        float: 'float',
-        float16: 'float',
-        float32: 'float',
-        float64: 'float',
-        bool: 'bool',
-        bstr: 'bytes',
-        bytes: 'bytes',
-        tstr: 'str',
-        text: 'str',
-        str: 'str',
-        nil: 'None',
-        null: 'None',
-    }
-}))
-
-describe('complex types 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 include all types in the union (TypedDict)', async () => {
-        await cli([cddlFile])
-
-        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).toContain('ArrayLocalValue')
-        expect(output).toContain('DateLocalValue')
-        expect(output).toContain('MapLocalValue')
-        expect(output).toContain('ObjectLocalValue')
-        expect(output).toContain('RegExpLocalValue')
-        expect(output).toContain('SetLocalValue')
-
-        expect(output).toContain('LocalValue = Union[ArrayLocalValue, DateLocalValue, MapLocalValue, ObjectLocalValue, RegExpLocalValue, SetLocalValue]')
-        expect(output).toMatchSnapshot()
-    })
-
-    it('should include all types in the union (Pydantic)', async () => {
-        await cli([cddlFile, '--pydantic'])
-
-        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).toContain('ArrayLocalValue')
-        expect(output).toContain('DateLocalValue')
-        expect(output).toContain('MapLocalValue')
-        expect(output).toContain('ObjectLocalValue')
-        expect(output).toContain('RegExpLocalValue')
-        expect(output).toContain('SetLocalValue')
-
-        expect(output).toContain('LocalValue = Union[ArrayLocalValue, DateLocalValue, MapLocalValue, ObjectLocalValue, RegExpLocalValue, SetLocalValue]')
-        expect(output).toMatchSnapshot()
-    })
-})

package/tests/group_choice.test.ts

@@ -1,88 +0,0 @@
-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: 'cddl2py',
-        version: '0.1.0',
-        author: 'Test Author',
-        description: 'Generate Python types from CDDL'
-    },
-    NATIVE_TYPE_MAP: {
-        any: 'Any',
-        number: 'Union[int, float]',
-        int: 'int',
-        uint: 'int',
-        nint: 'int',
-        float: 'float',
-        float16: 'float',
-        float32: 'float',
-        float64: 'float',
-        bool: 'bool',
-        bstr: 'bytes',
-        bytes: 'bytes',
-        tstr: 'str',
-        text: 'str',
-        str: 'str',
-        nil: 'None',
-        null: 'None',
-    }
-}))
-
-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 (TypedDict)', async () => {
-        await cli([groupChoiceCDDL])
-
-        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).toContain('ProxyConfiguration = Union[AutodetectProxyConfiguration, DirectProxyConfiguration, ManualProxyConfiguration]')
-
-        expect(output).toContain('class AutodetectProxyConfiguration(Extensible):')
-        expect(output).toContain('class DirectProxyConfiguration(Extensible):')
-        expect(output).toContain('class ManualProxyConfiguration(Extensible):')
-
-        expect(output).toMatchSnapshot()
-    })
-
-    it('should generate a union type for multiple group choices (Pydantic)', async () => {
-        await cli([groupChoiceCDDL, '--pydantic'])
-
-        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).toContain('ProxyConfiguration = Union[AutodetectProxyConfiguration, DirectProxyConfiguration, ManualProxyConfiguration]')
-
-        expect(output).toContain('class AutodetectProxyConfiguration(Extensible):')
-        expect(output).toContain('class DirectProxyConfiguration(Extensible):')
-        expect(output).toContain('class ManualProxyConfiguration(Extensible):')
-
-        expect(output).toMatchSnapshot()
-    })
-})

package/tests/literals.test.ts

@@ -1,63 +0,0 @@
-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: 'cddl2py',
-        version: '0.1.0',
-        author: 'Test Author',
-        description: 'Generate Python types from CDDL'
-    },
-    NATIVE_TYPE_MAP: {
-        any: 'Any',
-        number: 'Union[int, float]',
-        int: 'int',
-        uint: 'int',
-        nint: 'int',
-        float: 'float',
-        float16: 'float',
-        float32: 'float',
-        float64: 'float',
-        bool: 'bool',
-        bstr: 'bytes',
-        bytes: 'bytes',
-        tstr: 'str',
-        text: 'str',
-        str: 'str',
-        nil: 'None',
-        null: 'None',
-    }
-}))
-
-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')
-        expect(output).toMatchSnapshot()
-    })
-})

package/tests/mixin_union.test.ts

@@ -1,80 +0,0 @@
-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: 'cddl2py',
-        version: '0.1.0',
-        author: 'Test Author',
-        description: 'Generate Python types from CDDL'
-    },
-    NATIVE_TYPE_MAP: {
-        any: 'Any',
-        number: 'Union[int, float]',
-        int: 'int',
-        uint: 'int',
-        nint: 'int',
-        float: 'float',
-        float16: 'float',
-        float32: 'float',
-        float64: 'float',
-        bool: 'bool',
-        bstr: 'bytes',
-        bytes: 'bytes',
-        tstr: 'str',
-        text: 'str',
-        str: 'str',
-        nil: 'None',
-        null: 'None',
-    }
-}))
-
-describe('mixin and union 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 union type aliases for mixin choices (TypedDict)', 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')
-
-        expect(output).toContain('class Mixins(MixinA, MixinB):')
-        expect(output).toContain('UnionMixin = Union[MixinA, MixinB]')
-        expect(output).toMatchSnapshot()
-    })
-
-    it('should generate union type aliases for mixin choices (Pydantic)', async () => {
-        await cli([cddlFile, '--pydantic'])
-
-        expect(process.exit).not.toHaveBeenCalledWith(1)
-        expect(console.error).not.toHaveBeenCalled()
-
-        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
-
-        expect(output).toContain('class Mixins(MixinA, MixinB):')
-        expect(output).toContain('UnionMixin = Union[MixinA, MixinB]')
-        expect(output).toMatchSnapshot()
-    })
-})

package/tests/mod.test.ts

@@ -1,106 +0,0 @@
-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: 'cddl2py',
-        version: '0.1.0',
-        author: 'Test Author',
-        description: 'Generate Python types from CDDL'
-    },
-    NATIVE_TYPE_MAP: {
-        any: 'Any',
-        number: 'Union[int, float]',
-        int: 'int',
-        uint: 'int',
-        nint: 'int',
-        float: 'float',
-        float16: 'float',
-        float32: 'float',
-        float64: 'float',
-        bool: 'bool',
-        bstr: 'bytes',
-        bytes: 'bytes',
-        tstr: 'str',
-        text: 'str',
-        str: 'str',
-        nil: 'None',
-        null: 'None',
-    }
-}))
-
-describe('cddl2py CLI', () => {
-    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(/cddl2py/))
-        expect(process.exit).toHaveBeenCalledWith(0)
-    })
-
-    it('should print help when --help is set', async () => {
-        await cli(['foo', 'bar', '--help', 'barfoo'])
-
-        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/cddl2py/))
-        expect(process.exit).toHaveBeenCalledWith(0)
-    })
-
-    it('should print version (alias)', async () => {
-        await cli(['foo', '-v', 'bar'])
-
-        expect(console.log).toHaveBeenCalledWith('0.1.0')
-        expect(process.exit).toHaveBeenCalledWith(0)
-    })
-
-    it('should print version (long flag)', async () => {
-        await cli(['foo', '--version', 'bar'])
-
-        expect(console.log).toHaveBeenCalledWith('0.1.0')
-        expect(process.exit).toHaveBeenCalledWith(0)
-    })
-
-    it('should fail if first parameter is not pointing to a file', async () => {
-        await cli(['nonexistent.cddl'])
-
-        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)
-    })
-
-    it('should generate correct pydantic types for test.cddl', async () => {
-        await cli([
-            path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'test.cddl'),
-            '--pydantic'
-        ])
-
-        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

@@ -1,82 +0,0 @@
-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: 'cddl2py',
-        version: '0.1.0',
-        author: 'Test Author',
-        description: 'Generate Python types from CDDL'
-    },
-    NATIVE_TYPE_MAP: {
-        any: 'Any',
-        number: 'Union[int, float]',
-        int: 'int',
-        uint: 'int',
-        nint: 'int',
-        float: 'float',
-        float16: 'float',
-        float32: 'float',
-        float64: 'float',
-        bool: 'bool',
-        bstr: 'bytes',
-        bytes: 'bytes',
-        tstr: 'str',
-        text: 'str',
-        str: 'str',
-        nil: 'None',
-        null: 'None',
-    }
-}))
-
-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 (TypedDict)', 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')
-
-        expect(output).toContain('Choice = Union[OptionA, OptionB]')
-        expect(output).toContain('class OptionA(TypedDict):')
-        expect(output).toContain('class OptionB(TypedDict):')
-        expect(output).toMatchSnapshot()
-    })
-
-    it('should generate a union type alias for named group references (Pydantic)', async () => {
-        await cli([cddlFile, '--pydantic'])
-
-        expect(process.exit).not.toHaveBeenCalledWith(1)
-        expect(console.error).not.toHaveBeenCalled()
-
-        const output = vi.mocked(console.log).mock.calls.flat().join('\n')
-
-        expect(output).toContain('Choice = Union[OptionA, OptionB]')
-        expect(output).toContain('class OptionA(BaseModel):')
-        expect(output).toContain('class OptionB(BaseModel):')
-        expect(output).toMatchSnapshot()
-    })
-})

package/tests/transform.test.ts

@@ -1,149 +0,0 @@
-import url from 'node:url'
-import path from 'node:path'
-import { describe, it, expect } from 'vitest'
-import { parse } from 'cddl'
-import { transform } from '../src/index.js'
-import type { Variable, Group, Array as CDDLArray } from 'cddl'
-
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
-
-describe('transform', () => {
-    describe('variables', () => {
-        it('should transform a simple variable assignment', () => {
-            const assignment: Variable = {
-                Type: 'variable',
-                Name: 'device-address',
-                PropertyType: 'tstr',
-                Comments: [],
-                IsChoiceAddition: false
-            }
-            const output = transform([assignment])
-            expect(output).toContain('DeviceAddress = str')
-        })
-
-        it('should transform union variable', () => {
-            const assignment: Variable = {
-                Type: 'variable',
-                Name: 'my-type',
-                PropertyType: ['int', 'tstr'],
-                Comments: [],
-                IsChoiceAddition: false
-            }
-            const output = transform([assignment])
-            expect(output).toContain('MyType = Union[int, str]')
-        })
-
-        it('should transform bigint literals', () => {
-            const assignment: Variable = {
-                Type: 'variable',
-                Name: 'MyBigInt',
-                PropertyType: {
-                    Type: 'literal',
-                    Value: 9007199254740995n
-                } as any,
-                Comments: [],
-                IsChoiceAddition: false
-            }
-            const output = transform([assignment])
-            expect(output).toContain('MyBigInt = Literal[9007199254740995]')
-        })
-    })
-
-    describe('groups (TypedDict)', () => {
-        it('should transform a simple group into a TypedDict', () => {
-            const assignment: Group = {
-                Type: 'group',
-                Name: 'person',
-                IsChoiceAddition: false,
-                Properties: [
-                    { HasCut: false, Occurrence: { n: 1, m: 1 }, Name: 'age', Type: 'int', Comments: [] },
-                    { HasCut: false, Occurrence: { n: 1, m: 1 }, Name: 'name', Type: 'tstr', Comments: [] }
-                ] as any,
-                Comments: []
-            }
-            const output = transform([assignment])
-            expect(output).toContain('class Person(TypedDict):')
-            expect(output).toContain('    age: int')
-            expect(output).toContain('    name: str')
-        })
-
-        it('should handle optional fields with NotRequired', () => {
-            const assignment: Group = {
-                Type: 'group',
-                Name: 'person',
-                IsChoiceAddition: false,
-                Properties: [
-                    { HasCut: false, Occurrence: { n: 0, m: 1 }, Name: 'nickname', Type: 'tstr', Comments: [] },
-                ] as any,
-                Comments: []
-            }
-            const output = transform([assignment])
-            expect(output).toContain('class Person(TypedDict):')
-            expect(output).toContain('    nickname: NotRequired[str]')
-        })
-    })
-
-    describe('groups (Pydantic)', () => {
-        it('should transform a simple group into a Pydantic BaseModel', () => {
-            const assignment: Group = {
-                Type: 'group',
-                Name: 'person',
-                IsChoiceAddition: false,
-                Properties: [
-                    { HasCut: false, Occurrence: { n: 1, m: 1 }, Name: 'age', Type: 'int', Comments: [] },
-                    { HasCut: false, Occurrence: { n: 1, m: 1 }, Name: 'name', Type: 'tstr', Comments: [] }
-                ] as any,
-                Comments: []
-            }
-            const output = transform([assignment], { pydantic: true })
-            expect(output).toContain('from pydantic import BaseModel')
-            expect(output).toContain('class Person(BaseModel):')
-            expect(output).toContain('    age: int')
-            expect(output).toContain('    name: str')
-        })
-
-        it('should handle optional fields with Optional and None default', () => {
-            const assignment: Group = {
-                Type: 'group',
-                Name: 'person',
-                IsChoiceAddition: false,
-                Properties: [
-                    { HasCut: false, Occurrence: { n: 0, m: 1 }, Name: 'nickname', Type: 'tstr', Comments: [] },
-                ] as any,
-                Comments: []
-            }
-            const output = transform([assignment], { pydantic: true })
-            expect(output).toContain('class Person(BaseModel):')
-            expect(output).toContain('    nickname: Optional[str] = None')
-        })
-    })
-
-    describe('arrays', () => {
-        it('should transform an array definition', () => {
-            const assignment: CDDLArray = {
-                Type: 'array',
-                Name: 'my-list',
-                Values: [
-                    { HasCut: false, Occurrence: { n: 0, m: Infinity }, Name: '', Type: 'int', Comments: [] }
-                ] as any,
-                Comments: []
-            }
-            const output = transform([assignment])
-            expect(output).toContain('MyList = list[int]')
-        })
-    })
-
-    describe('snapshot tests with parsed CDDL', () => {
-        it('should transform test.cddl TypedDict correctly', () => {
-            const ast = parse(path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'test.cddl'))
-            const output = transform(ast)
-            expect(output).toMatchSnapshot()
-        })
-
-        it('should transform test.cddl Pydantic correctly', () => {
-            const ast = parse(path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'test.cddl'))
-            const output = transform(ast, { pydantic: true })
-            expect(output).toMatchSnapshot()
-        })
-    })
-})