cddl 0.13.0 → 0.14.0

package/tests/commands/repl.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, vi, expect } from 'vitest'
+import repl from 'node:repl'
+import { builder, handler, evaluate } from '../../src/cli/commands/repl.js'
+import { Tokens } from '../../src/tokens.js'
+
+describe('repl command', () => {
+    it('builder', () => {
+        const yargs: any = {}
+        yargs.epilogue = vi.fn().mockReturnValue(yargs)
+        yargs.help = vi.fn().mockReturnValue(yargs)
+        builder(yargs)
+
+        expect(yargs.epilogue).toHaveBeenCalledTimes(1)
+        expect(yargs.help).toHaveBeenCalledTimes(1)
+    })
+
+    describe('handler', () => {
+        it('starts repl', () => {
+            const startSpy = vi.spyOn(repl, 'start').mockReturnValue({} as any)
+            handler()
+            expect(startSpy).toHaveBeenCalledWith(expect.objectContaining({
+                prompt: '> ',
+                eval: evaluate
+            }))
+            startSpy.mockRestore()
+        })
+    })
+
+    describe('evaluate', () => {
+        it('returns error if no input', () => {
+            const cb = vi.fn()
+            evaluate('', {}, '', cb)
+            expect(cb).toHaveBeenCalledWith(expect.any(Error), null)
+        })
+
+        it('tokenizes input using Lexer', () => {
+            const cb = vi.fn()
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+            evaluate('foo = 1', {}, '', cb)
+
+            expect(consoleSpy).toHaveBeenCalledTimes(3) // foo, =, 1
+            expect(consoleSpy).toHaveBeenNthCalledWith(1, expect.objectContaining({ Type: Tokens.IDENT, Literal: 'foo' }))
+            expect(consoleSpy).toHaveBeenNthCalledWith(2, expect.objectContaining({ Type: Tokens.ASSIGN, Literal: '=' }))
+            expect(consoleSpy).toHaveBeenNthCalledWith(3, expect.objectContaining({ Type: Tokens.NUMBER, Literal: '1' }))
+
+            expect(cb).toHaveBeenCalledWith(null, null)
+
+            consoleSpy.mockRestore()
+        })
+    })
+})

package/tests/commands/validate.test.ts

@@ -0,0 +1,66 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, vi, expect, beforeEach, afterAll } from 'vitest'
+import { builder, handler } from '../../src/cli/commands/validate.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const validCDDL = path.join(__dirname, '..', '..', '..', '..', 'examples', 'webdriver', 'local.cddl')
+const buggyCDDL = path.join(__dirname, '..', '..', '..', '..', 'examples', 'commons', 'buggy.cddl')
+
+describe('validate command', () => {
+    it('builder', () => {
+        const yargs: any = {}
+        yargs.epilogue = vi.fn().mockReturnValue(yargs)
+        yargs.help = vi.fn().mockReturnValue(yargs)
+        builder(yargs)
+
+        expect(yargs.epilogue).toBeCalledTimes(1)
+        expect(yargs.help).toBeCalledTimes(1)
+    })
+
+    describe('handler', () => {
+        const consoleLogOrig = console.log.bind(console)
+        const consoleErrorOrig = console.error.bind(console)
+        const processExitOrig = process.exit.bind(process)
+
+        beforeEach(() => {
+            // @ts-expect-error
+            process.exit = vi.fn()
+            console.log = vi.fn()
+            console.error = vi.fn()
+        })
+
+        afterAll(() => {
+            process.exit = processExitOrig
+            console.log = consoleLogOrig
+            console.error = consoleErrorOrig
+        })
+
+        it('fails if file does not exist', () => {
+            handler({ filePath: '/foo/bar', _: [], $0: '' })
+            expect(process.exit).toBeCalledTimes(1)
+            expect(console.error).toBeCalledTimes(1)
+            expect(process.exit).toBeCalledWith(1)
+        })
+
+        it('fails if cddl file is buggy', () => {
+            handler({ filePath: buggyCDDL, _: [], $0: '' })
+            expect(process.exit).toBeCalledTimes(1)
+            expect(console.error).toBeCalledTimes(1)
+            expect(process.exit).toBeCalledWith(1)
+        })
+
+        it('passes if cddl file is valid', () => {
+            handler({ filePath: validCDDL, _: [], $0: '' })
+            expect(process.exit).toBeCalledTimes(0)
+            expect(console.log).toBeCalledTimes(1)
+        })
+
+        it('handles relative paths', () => {
+            handler({ filePath: 'relative/path/to/file.cddl', _: [], $0: '' })
+            expect(process.exit).toBeCalledTimes(1)
+            expect(console.error).toBeCalledTimes(1)
+            expect(process.exit).toBeCalledWith(1)
+        })
+    })
+})

package/tests/complex_types.test.ts

@@ -0,0 +1,18 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect } from 'vitest'
+
+import Parser from '../src/parser.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+
+describe('complex types', () => {
+    it('can parse complex types correctly', () => {
+        const p = new Parser(path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'complex_types.cddl'))
+        const ast = p.parse()
+        const localValue = ast.find((item: any) => item.Name === 'LocalValue')
+
+        expect(localValue).toBeDefined()
+        expect(localValue).toMatchSnapshot()
+    })
+})

package/tests/examples.test.ts

@@ -0,0 +1,25 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect } from 'vitest'
+
+import Parser from '../src/parser.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+
+describe('examples', () => {
+    describe('common', () => {
+        const testCases: { name: string, fixture: string }[] = [
+            { name: 'can parse group choice', fixture: 'group_choice.cddl' },
+            { name: 'can parse literals', fixture: 'literals.cddl' },
+            { name: 'can parse mixin union', fixture: 'mixin_union.cddl' },
+            { name: 'can parse named group choice', fixture: 'named_group_choice.cddl' }
+        ]
+
+        for (const { name, fixture } of testCases) {
+            it(name, async () => {
+                const p = new Parser(path.join(__dirname, '..', '..', '..', 'examples', 'commons', fixture))
+                expect(p.parse()).toMatchSnapshot()
+            })
+        }
+    })
+})

package/tests/group-choices.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import Parser from '../src/parser.js'
+import * as fs from 'node:fs'
+
+vi.mock('node:fs')
+
+describe('Group Choice Parsing', () => {
+    const parse = (cddl: string) => {
+        vi.mocked(fs.readFileSync).mockReturnValue(cddl)
+        const parser = new Parser('dummy.cddl')
+        return parser.parse()
+    }
+
+    beforeEach(() => {
+        vi.clearAllMocks()
+    })
+
+    describe('Group Choice (//)', () => {
+        it('should verify group choice operator //', () => {
+            const cddl = `
+                mygroup = (int // text)
+            `
+            const ast = parse(cddl)
+            expect(ast).toMatchSnapshot()
+        })
+
+        it('should throw error when group choice operator // is at start of group', () => {
+            const cddl = `
+                mygroup = (// int)
+            `
+            expect(() => parse(cddl)).toThrowError('Unexpected group choice operator "//" at start of group')
+        })
+
+        it('should parse nested group choice', () => {
+            const cddl = `
+                mygroup = ((int // text))
+            `
+            const ast = parse(cddl)
+            expect(ast).toMatchSnapshot()
+        })
+
+        it('should parse group choice with multiple items', () => {
+             const cddl = `
+                mygroup = (int, text // float)
+            `
+            const ast = parse(cddl)
+            expect(ast).toMatchSnapshot()
+        })
+    })
+
+    describe('Map Group Choice', () => {
+        it('should parse group choice inside map', () => {
+            const cddl = `
+                mymap = {
+                    "a" => 1 //
+                    "b" => 2
+                }
+            `
+            const ast = parse(cddl)
+            expect(ast).toMatchSnapshot()
+        })
+    })
+
+    describe('Type Choice (/)', () => {
+        it('should parse type choice inside group', () => {
+             const cddl = `
+                mygroup = (int / text)
+            `
+            const ast = parse(cddl)
+            expect(ast).toMatchSnapshot()
+        })
+
+        // This tests the change: closingTokens.includes(Tokens.RPAREN) && this.peekToken.Type === Tokens.SLASH
+        it('should correctly handle slash in mixed context', () => {
+            const cddl = `
+                myrule = [ (int / text) ]
+            `
+            const ast = parse(cddl)
+            expect(ast).toMatchSnapshot()
+        })
+    })
+
+    describe('Blocks with Braces', () => {
+        // Covers changes in openSegment and parseAssignmentValue regarding Tokens.LBRACE
+        it('should parse nested group inside map', () => {
+            // This relates to the removal of special LPAREN handling inside LBRACE in openSegment
+            const cddl = `
+                myrule = { (int) }
+            `
+            const ast = parse(cddl)
+            // Expecting parsing to succeed and structure to be correct
+            expect(ast).toMatchSnapshot()
+        })
+
+         it('should parse bare group inside brace', () => {
+            const cddl = `
+                myrule = { int }
+            `
+            const ast = parse(cddl)
+            expect(ast).toMatchSnapshot()
+        })
+    })
+})

package/tests/lexer.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest'
+
+import { Tokens } from '../src/tokens.js'
+import Lexer from '../src/lexer.js'
+
+describe('lexer', () => {
+    it('should allow to read token', () => {
+        const input = '=+(){},/<>'
+        const tests = [
+            [Tokens.ASSIGN, '='],
+            [Tokens.PLUS, '+'],
+            [Tokens.LPAREN, '('],
+            [Tokens.RPAREN, ')'],
+            [Tokens.LBRACE, '{'],
+            [Tokens.RBRACE, '}'],
+            [Tokens.COMMA, ','],
+            [Tokens.SLASH, '/'],
+            [Tokens.LT, '<'],
+            [Tokens.GT, '>']
+        ]
+
+        const l = new Lexer(input)
+        for (const [Type, Literal] of tests) {
+            const token = l.nextToken()
+            expect(token.Type).toBe(Type)
+            expect(token.Literal).toBe(Literal)
+        }
+    })
+
+    it('should read identifiers and comments', () => {
+        const input = '   headers,       ; Headers for the recipient'
+        const tests = [
+            [Tokens.IDENT, 'headers'],
+            [Tokens.COMMA, ','],
+            [Tokens.COMMENT, '; Headers for the recipient']
+        ]
+
+        const l = new Lexer(input)
+        for (const [Type, Literal] of tests) {
+            const token = l.nextToken()
+            expect(token.Type).toBe(Type)
+            expect(token.Literal).toBe(Literal)
+        }
+    })
+
+    it('should correctly report location info', () => {
+        const input = 'a = 1'
+        const l = new Lexer(input)
+
+        // consume tokens until EOF
+        while (l.nextToken().Type !== 'EOF') {}
+
+        // consume more EOFs to push position further
+        for (let i = 0; i < 10; ++i) {
+            l.nextToken()
+        }
+
+        // This should trigger the fallback
+        const locEnd = l.getLocation()
+        expect(locEnd.line).toBe(0)
+        expect(locEnd.position).toBe(0)
+    })
+})

package/tests/module.test.ts

@@ -0,0 +1,21 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect } from 'vitest'
+
+import CDDL from '../src/index.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+const validCDDL = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'arrays.cddl')
+const buggyCDDL = path.join(__dirname, '..', '..', '..', 'examples', 'commons', 'buggy.cddl')
+
+describe('validate', () => {
+    it('should return a json in success case', () => {
+        const ast = CDDL.parse(validCDDL)
+        expect(typeof ast).toBe('object')
+    })
+
+    it('should throw an error if invalud', () => {
+        expect(() => CDDL.parse(buggyCDDL))
+            .toThrow()
+    })
+})

package/tests/parser.test.ts

@@ -0,0 +1,44 @@
+import url from 'node:url'
+import path from 'node:path'
+import fs from 'node:fs'
+import { describe, it, expect, vi } from 'vitest'
+
+import Parser from '../src/parser.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+
+describe('parser', () => {
+    const testCases: { name: string, fixture: string }[] = [
+        { name: 'should correctly parse CDDL file', fixture: 'example.cddl' },
+        { name: 'can parse compositions', fixture: 'compositions.cddl' },
+        { name: 'can parse ranges', fixture: 'ranges.cddl' },
+        { name: 'can parse occurrences', fixture: 'occurrences.cddl' },
+        { name: 'can parse arrays', fixture: 'arrays.cddl' },
+        { name: 'can parse unwrapped arrays', fixture: 'unwrapping.cddl' },
+        { name: 'can parse comments', fixture: 'comments.cddl' },
+        { name: 'can parse choices', fixture: 'choices.cddl' },
+        { name: 'can parse nested groups', fixture: 'nested.cddl' },
+        { name: 'can parse operators', fixture: 'operators.cddl' }
+    ]
+
+    for (const { name, fixture } of testCases) {
+        it(name, async () => {
+            const p = new Parser(path.join(__dirname, '..', '..', '..', 'examples', 'commons', fixture))
+            expect(p.parse()).toMatchSnapshot()
+        })
+    }
+
+    it('throws if group identifier is missing', () => {
+        vi.spyOn(fs, 'readFileSync').mockReturnValue('=')
+        const p = new Parser('foo.cddl')
+        expect(() => p.parse()).toThrow('group identifier expected')
+        vi.restoreAllMocks()
+    })
+
+    it('throws if assignment operator is missing', () => {
+        vi.spyOn(fs, 'readFileSync').mockReturnValue('groupName bar')
+        const p = new Parser('foo.cddl')
+        expect(() => p.parse()).toThrow('group identifier expected')
+        vi.restoreAllMocks()
+    })
+})

package/tests/webdriver-local.test.ts

@@ -0,0 +1,15 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect } from 'vitest'
+
+import Parser from '../src/parser.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+
+describe('webdriver local cddl', () => {
+    it('can parse local.cddl', () => {
+        const filePath = path.join(__dirname, '..', '..', '..', 'examples', 'webdriver', 'local.cddl')
+        const p = new Parser(filePath)
+        expect(p.parse()).toMatchSnapshot()
+    })
+})

package/tests/webdriver-remote.test.ts

@@ -0,0 +1,15 @@
+import url from 'node:url'
+import path from 'node:path'
+import { describe, it, expect } from 'vitest'
+
+import Parser from '../src/parser.js'
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
+
+describe('webdriver remote cddl', () => {
+    it('can parse remote.cddl', () => {
+        const filePath = path.join(__dirname, '..', '..', '..', 'examples', 'webdriver', 'remote.cddl')
+        const p = new Parser(filePath)
+        expect(p.parse()).toMatchSnapshot()
+    })
+})

package/tsconfig.json

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