Glossary unit tests, fix a few caching issues in previous ones

src/compile/recipe.ts

@@ -62,9 +62,9 @@ export async function build(rootFile: string, langId: string, buildLoop: () => P
 
     // Create output subdirectories for included files
     if (tools?.map(tool => tool.command).includes('latexmk') && rootFile === lw.root.subfiles.path && lw.root.file.path) {
-        createOutputSubFolders(lw.root.file.path)
+        await createOutputSubFolders(lw.root.file.path)
     } else {
-        createOutputSubFolders(rootFile)
+        await createOutputSubFolders(rootFile)
     }
 
     // Check for invalid toolchain
@@ -88,14 +88,14 @@ export async function build(rootFile: string, langId: string, buildLoop: () => P
  *
  * @param {string} rootFile - Path to the root LaTeX file.
  */
-function createOutputSubFolders(rootFile: string) {
+async function createOutputSubFolders(rootFile: string) {
     const rootDir = path.dirname(rootFile)
     let outDir = lw.file.getOutDir(rootFile)
     if (!path.isAbsolute(outDir)) {
         outDir = path.resolve(rootDir, outDir)
     }
     logger.log(`outDir: ${outDir} .`)
-    lw.cache.getIncludedTeX(rootFile).forEach(async file => {
+    for (const file of lw.cache.getIncludedTeX(rootFile)) {
         const relativePath = path.dirname(file.replace(rootDir, '.'))
         const fullOutDir = path.resolve(outDir, relativePath)
         // To avoid issues when fullOutDir is the root dir
@@ -120,7 +120,7 @@ function createOutputSubFolders(rootFile: string) {
                 throw(e)
             }
         }
-    })
+    }
 }
 
 

test/suites/04_intellisense.test.ts

@@ -139,7 +139,7 @@ suite('Intellisense test suite', () => {
         assert.ok(suggestions.labels.includes('\\includefrom{}{}'))
         let snippet = suggestions.items.filter(item => item.label === '\\includefrom{}{}')[0].insertText
         assert.ok(snippet)
-        assert.ok(typeof snippet !== 'string')
+        assert.ok(snippet instanceof vscode.SnippetString)
         assert.ok(snippet.value.includes('${1:'))
 
         await vscode.workspace.getConfiguration('latex-workshop').update('intellisense.argumentHint.enabled', false)
@@ -151,7 +151,7 @@ suite('Intellisense test suite', () => {
         assert.ok(suggestions.labels.includes('\\includefrom{}{}'))
         snippet = suggestions.items.filter(item => item.label === '\\includefrom{}{}')[0].insertText
         assert.ok(snippet)
-        assert.ok(typeof snippet !== 'string')
+        assert.ok(snippet instanceof vscode.SnippetString)
         assert.ok(!snippet.value.includes('${1:'))
     })
 

test/units/04_core_root.test.ts

@@ -450,9 +450,7 @@ describe(path.basename(__filename).split('.')[0] + ':', () => {
 
             set.config('latex.search.rootFiles.include', [ `${fixture}/find_workspace/**/*.tex` ])
             set.root(fixture, 'find_workspace', 'main.tex')
-            const stub = mock.activeTextEditor(texPath, '\\documentclass{article}\n')
             await lw.root.find()
-            stub.restore()
 
             assert.hasLog('Try finding root from current workspaceRootDir:')
             assert.strictEqual(lw.root.file.path, texPath)

test/units/06_compile_recipe.test.ts

@@ -25,6 +25,7 @@ describe(path.basename(__filename).split('.')[0] + ':', () => {
     })
 
     afterEach(() => {
+        queue.clear()
         getOutDirStub.resetHistory()
         getIncludedTeXStub.resetHistory()
         mkdirStub.resetHistory()
@@ -186,7 +187,6 @@ describe(path.basename(__filename).split('.')[0] + ':', () => {
     })
 
     describe('lw.compile->recipe.createOutputSubFolders', () => {
-
         beforeEach(() => {
             getIncludedTeXStub.returns([ set.root('main.tex') ])
         })
@@ -226,6 +226,7 @@ describe(path.basename(__filename).split('.')[0] + ':', () => {
             await build(rootFile, 'latex', async () => {})
             stub.restore()
 
+            assert.strictEqual(mkdirStub.callCount, 1)
             assert.pathStrictEqual(mkdirStub.getCall(0).args[0] as string, expectedOutDir)
             assert.deepStrictEqual(mkdirStub.getCall(0).args[1], { recursive: true })
         })

test/units/11_parser_tex.test.ts

@@ -8,6 +8,7 @@ import type * as Ast from '@unified-latex/unified-latex-types'
 describe(path.basename(__filename).split('.')[0] + ':', () => {
     before(() => {
         mock.init(lw, 'parser')
+        ;(lw.cache.paths as sinon.SinonStub).returns([])
     })
 
     after(() => {

test/units/15_completion_macro.test.ts

@@ -116,8 +116,8 @@ describe(path.basename(__filename).split('.')[0] + ':', () => {
 
             const suggestion = getSuggestions().find(s => s.label === '\\RenewAcroPreset{}{}')
             const snippet = suggestion?.insertText
-            assert.ok(typeof snippet !== 'string')
-            assert.ok(!snippet?.value.includes('%keyvals'), snippet?.value)
+            assert.ok(snippet instanceof vscode.SnippetString)
+            assert.ok(!snippet.value.includes('%keyvals'), snippet?.value)
         })
 
         it('should not provide argument hints if `intellisense.argumentHint.enabled` is false', async () => {
@@ -126,14 +126,14 @@ describe(path.basename(__filename).split('.')[0] + ':', () => {
 
             let suggestion = getSuggestions().find(s => s.label === '\\includefrom{}{}')
             let snippet = suggestion?.insertText
-            assert.ok(typeof snippet !== 'string')
-            assert.ok(snippet?.value.includes('${1:'))
+            assert.ok(snippet instanceof vscode.SnippetString)
+            assert.ok(snippet.value.includes('${1:'))
 
             set.config('intellisense.argumentHint.enabled', false)
             suggestion = getSuggestions().find(s => s.label === '\\includefrom{}{}')
             snippet = suggestion?.insertText
-            assert.ok(typeof snippet !== 'string')
-            assert.ok(!snippet?.value.includes('${1:'))
+            assert.ok(snippet instanceof vscode.SnippetString)
+            assert.ok(!snippet.value.includes('${1:'))
         })
 
         it('should add new macros from `intellisense.command.user`', async () => {

test/units/18_completion_package.test.ts

@@ -73,5 +73,15 @@ describe(path.basename(__filename).split('.')[0] + ':', () => {
             assert.ok(labels.includes('\\import{}{}'))
             assert.ok(labels.includes('\\lstinputlisting{}'))
         })
+
+        it('should provide base KOMAScript macros/envs in KOMAScript class', async () => {
+            readStub.resolves('\\documentclass{scrartcl}')
+            await lw.cache.refreshCache(texPath)
+            const labels = getMacros()
+            // in class-scrartcl.cwl
+            assert.ok(labels.includes('\\addpart{}'))
+            // in base
+            assert.ok(labels.includes('\\addchap{}'))
+        })
     })
 })

test/units/20_completion_documentclass.test.ts

@@ -2,23 +2,15 @@ import * as vscode from 'vscode'
 import * as path from 'path'
 import * as sinon from 'sinon'
 import { lw } from '../../src/lw'
-import { assert, get, mock, set } from './utils'
+import { assert, get, mock } from './utils'
 import { provider } from '../../src/completion/completer/class'
 
 describe(path.basename(__filename).split('.')[0] + ':', () => {
     const fixture = path.basename(__filename).split('.')[0]
     const texPath = get.path(fixture, 'main.tex')
-    let readStub: sinon.SinonStub
 
     before(() => {
         mock.init(lw, 'root', 'cache', 'parser', 'completion')
-        readStub = sinon.stub(lw.file, 'read')
-    })
-
-    beforeEach(async () => {
-        set.root(texPath)
-        readStub.resolves('\\usepackage{import}\n\\usepackage[savemem]{listings}')
-        await lw.cache.refreshCache(texPath)
     })
 
     after(() => {

test/units/21_completion_input.test.ts

@@ -6,20 +6,16 @@ import { assert, get, mock, set } from './utils'
 import { inputProvider, importProvider, subimportProvider } from '../../src/completion/completer/input'
 import type { CompletionProvider } from '../../src/types'
 
-describe.only(path.basename(__filename).split('.')[0] + ':', () => {
+describe(path.basename(__filename).split('.')[0] + ':', () => {
     const fixture = path.basename(__filename).split('.')[0]
     const texPath = get.path(fixture, 'main.tex')
-    let readStub: sinon.SinonStub
 
     before(() => {
         mock.init(lw, 'root', 'cache', 'parser', 'completion')
-        readStub = sinon.stub(lw.file, 'read')
     })
 
-    beforeEach(async () => {
+    beforeEach(() => {
         set.root(texPath)
-        readStub.resolves('\\usepackage{import}\n\\usepackage[savemem]{listings}')
-        await lw.cache.refreshCache(texPath)
     })
 
     after(() => {
@@ -79,7 +75,7 @@ describe.only(path.basename(__filename).split('.')[0] + ':', () => {
         it('should provide \\subimport subfile suggestions with extension-less inserted text', () => {
             const suggestions = getSuggestions(subimportProvider, ['\\subimport{sub}{', 'import', 'sub', ''])
 
-            assert.ok(!suggestions.some(s => typeof s.insertText !== 'string' && s.insertText?.value.includes('.tex')))
+            assert.ok(!suggestions.some(s => s.insertText instanceof vscode.SnippetString && s.insertText?.value.includes('.tex')))
         })
     })
 })

test/units/22_completion_glossary.test.ts

@@ -0,0 +1,110 @@
+import * as vscode from 'vscode'
+import * as path from 'path'
+import * as sinon from 'sinon'
+import { lw } from '../../src/lw'
+import { assert, get, mock, set } from './utils'
+import { provider } from '../../src/completion/completer/glossary'
+
+describe(path.basename(__filename).split('.')[0] + ':', () => {
+    const fixture = path.basename(__filename).split('.')[0]
+    const texPath = get.path(fixture, 'main.tex')
+    const glsPath = get.path(fixture, 'gls.tex')
+    let readStub: sinon.SinonStub
+
+    before(() => {
+        mock.init(lw, 'root', 'cache', 'parser', 'completion')
+        readStub = sinon.stub(lw.file, 'read')
+    })
+
+    beforeEach(() => {
+        set.root(texPath)
+    })
+
+    after(() => {
+        sinon.restore()
+    })
+
+    describe('lw.completion->glossary', () => {
+        function getSuggestions() {
+            return provider.from(['', ''], {
+                uri: vscode.Uri.file(texPath),
+                langId: 'latex',
+                line: '',
+                position: new vscode.Position(0, 0),
+            })
+        }
+
+        it('should parse and provide \\newacronym definition', async () => {
+            readStub.resolves('\\newacronym{rf}{RF}{radio-frequency}')
+            await lw.cache.refreshCache(texPath)
+
+            const suggestions = getSuggestions()
+
+            assert.ok(suggestions.some(s => s.label === 'rf'))
+            assert.strictEqual(suggestions.find(s => s.label === 'rf')?.detail, 'radio-frequency')
+        })
+
+        it('should reject ill-formed glossary definitions', async () => {
+            readStub.resolves('\\newacronym[argopt]{EPE_x}{E} % ill-formed entry')
+            await lw.cache.refreshCache(texPath)
+
+            const suggestions = getSuggestions()
+
+            assert.ok(!suggestions.some(s => s.label === 'EPE_x'))
+        })
+
+        it('should parse and provide \\newglossaryentry definition', async () => {
+            readStub.resolves('\\newglossaryentry{vs_code}{name=VSCode, description=Editor}')
+            await lw.cache.refreshCache(texPath)
+
+            const suggestions = getSuggestions()
+
+            assert.ok(suggestions.some(s => s.label === 'vs_code'))
+            assert.strictEqual(suggestions.find(s => s.label === 'vs_code')?.detail, 'Editor')
+        })
+
+        it('should parse and provide \\newglossaryentry definition with curly brace fence', async () => {
+            readStub.resolves('\\newglossaryentry{lw}{name={LaTeX Workshop}, description={What this extension is $\\mathbb{A}$}}')
+            await lw.cache.refreshCache(texPath)
+
+            const suggestions = getSuggestions()
+
+            assert.ok(suggestions.some(s => s.label === 'lw'))
+            assert.strictEqual(suggestions.find(s => s.label === 'lw')?.detail, 'What this extension is $\\mathbb{A}$')
+        })
+
+        it('should parse and provide \\newabbr definition', async () => {
+            readStub.resolves('\\newabbr{abbr_x}{Ebbr}{A first abbreviation}')
+            await lw.cache.refreshCache(texPath)
+
+            const suggestions = getSuggestions()
+
+            assert.ok(suggestions.some(s => s.label === 'abbr_x'))
+            assert.strictEqual(suggestions.find(s => s.label === 'abbr_x')?.detail, 'A first abbreviation')
+        })
+
+        it('should parse and provide \\newabbreviation definition', async () => {
+            readStub.resolves('\\newabbreviation[optional arg]{abbr_y}{Ybbr}{A second abbreviation}')
+            await lw.cache.refreshCache(texPath)
+
+            const suggestions = getSuggestions()
+
+            assert.ok(suggestions.some(s => s.label === 'abbr_y'))
+            assert.strictEqual(suggestions.find(s => s.label === 'abbr_y')?.detail, 'A second abbreviation')
+        })
+
+        it('should parse and provide glossary definitions in another file given in \\loadglsentries', async () => {
+            const stub = sinon.stub(lw.file, 'exists').resolves({ type: 1, ctime: 0, mtime: 0, size: 0 })
+            readStub.resolves('\\newacronym{rf}{RF}{radio-frequency}')
+            readStub.withArgs(texPath).resolves('\\loadglsentries{gls}')
+            await lw.cache.refreshCache(texPath)
+            await lw.cache.refreshCache(glsPath)
+            stub.restore()
+
+            const suggestions = getSuggestions()
+
+            assert.ok(suggestions.some(s => s.label === 'rf'))
+            assert.strictEqual(suggestions.find(s => s.label === 'rf')?.detail, 'radio-frequency')
+        })
+    })
+})

test/units/index.ts

@@ -8,8 +8,8 @@ export function run(): Promise<void> {
     const mocha = new Mocha({
         ui: 'bdd',
         color: true,
-        timeout: process.env['LATEXWORKSHOP_CITEST'] ? 10000 : 8000,
-        retries: process.env['LATEXWORKSHOP_CITEST'] ? 8 : 2
+        timeout: process.env['LATEXWORKSHOP_CITEST'] ? 10000 : 5000,
+        retries: process.env['LATEXWORKSHOP_CITEST'] ? 2 : 0
     })
 
     mocha.suite.on('pre-require', (context) => {