"use strict";
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Red Hat. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const vscode_languageserver_types_1 = require("vscode-languageserver-types");
const yamlSettings_1 = require("../src/yamlSettings");
const serviceSetup_1 = require("./utils/serviceSetup");
const testHelper_1 = require("./utils/testHelper");
const chai_1 = require("chai");
const verifyError_1 = require("./utils/verifyError");
const path = require("path");
describe('Auto Completion Fix Tests', () => {
    let languageSettingsSetup;
    let languageService;
    let languageHandler;
    let yamlSettings;
    let schemaProvider;
    before(() => {
        languageSettingsSetup = new serviceSetup_1.ServiceSetup().withCompletion().withSchemaFileMatch({
            uri: 'https://raw.githubusercontent.com/yannh/kubernetes-json-schema/master/v1.32.1-standalone-strict/all.json',
            fileMatch: [testHelper_1.SCHEMA_ID],
        });
        const { languageService: langService, languageHandler: langHandler, yamlSettings: settings, schemaProvider: testSchemaProvider, } = (0, testHelper_1.setupLanguageService)(languageSettingsSetup.languageSettings);
        languageService = langService;
        languageHandler = langHandler;
        yamlSettings = settings;
        schemaProvider = testSchemaProvider;
    });
    /**
     * Generates a completion list for the given document and caret (cursor) position.
     * @param content The content of the document.
     * @param line starts with 0 index
     * @param character starts with 1 index
     * @returns A list of valid completions.
     */
    function parseSetup(content, line, character) {
        const testTextDocument = (0, testHelper_1.setupSchemaIDTextDocument)(content);
        yamlSettings.documents = new yamlSettings_1.TextDocumentTestManager();
        yamlSettings.documents.set(testTextDocument);
        return languageHandler.completionHandler({
            position: vscode_languageserver_types_1.Position.create(line, character),
            textDocument: testTextDocument,
        });
    }
    /**
     * Generates a completion list for the given document and caret (cursor) position.
     * @param content The content of the document.
     * The caret is located in the content using `|` bookends.
     * For example, `content = 'ab|c|d'` places the caret over the `'c'`, at `position = 2`
     * @returns A list of valid completions.
     */
    function parseCaret(content) {
        const { position, content: content2 } = (0, testHelper_1.caretPosition)(content);
        const testTextDocument = (0, testHelper_1.setupSchemaIDTextDocument)(content2);
        yamlSettings.documents = new yamlSettings_1.TextDocumentTestManager();
        yamlSettings.documents.set(testTextDocument);
        return languageHandler.completionHandler({
            position: testTextDocument.positionAt(position),
            textDocument: testTextDocument,
        });
    }
    afterEach(() => {
        schemaProvider.deleteSchema(testHelper_1.SCHEMA_ID);
        languageService.configure(languageSettingsSetup.languageSettings);
    });
    it('should show completion on map under array', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'array',
            items: {
                type: 'object',
                properties: {
                    from: {
                        type: 'object',
                        properties: {
                            foo: {
                                type: 'boolean',
                            },
                        },
                    },
                },
            },
        });
        const content = '- from:\n   | |'; // len: 12, pos: 11
        const completion = await parseCaret(content);
        (0, chai_1.expect)(completion.items).lengthOf(1);
        (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('foo', 'foo: ', 1, 3, 1, 4, 10, 2, {
            documentation: '',
        }));
    });
    it('completion with array objects', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'array',
            items: {
                type: 'object',
                properties: {
                    prop1: {
                        type: 'string',
                    },
                    prop2: {
                        type: 'string',
                    },
                    prop3: {
                        type: 'string',
                    },
                },
            },
        });
        const content = '- prop1: a\n   | |'; // len: 12, pos: 11
        const completion = await parseCaret(content);
        (0, chai_1.expect)(completion.items).lengthOf(2);
        (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('prop2', 'prop2: ', 1, 3, 1, 4, 10, 2, {
            documentation: '',
        }));
        (0, chai_1.expect)(completion.items[1]).eql((0, verifyError_1.createExpectedCompletion)('prop3', 'prop3: ', 1, 3, 1, 4, 10, 2, {
            documentation: '',
        }));
    });
    it('should show completion on array empty array item', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'array',
            items: {
                type: 'object',
                properties: {
                    from: {
                        type: 'object',
                        properties: {
                            foo: {
                                type: 'boolean',
                            },
                        },
                    },
                },
            },
        });
        const content = '- '; // len: 2
        const completion = await parseSetup(content, 0, 2);
        (0, chai_1.expect)(completion.items).lengthOf(1);
        (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('from', 'from:\n    ', 0, 2, 0, 2, 10, 2, {
            documentation: '',
        }));
    });
    it('should show completion items in the middle of map in array', async () => {
        const content = `apiVersion: v1
kind: Pod
metadata:
  name: foo
spec:
  containers:
    - name: test
      
      image: alpine
    `; // len: 90
        const completion = await parseSetup(content, 7, 6);
        (0, chai_1.expect)(completion.items).length.greaterThan(1);
    });
    it('should show completion on array item on first line', async () => {
        const content = '-d'; // len: 2
        const completion = await parseSetup(content, 0, 1);
        (0, chai_1.expect)(completion.items).is.empty;
    });
    it('should complete without error on map inside array', async () => {
        const content = '- foo\n- bar:\n    so'; // len: 19
        const completion = await parseSetup(content, 2, 6);
        (0, chai_1.expect)(completion.items).is.empty;
    });
    it('should complete  array', async () => {
        // eslint-disable-next-line @typescript-eslint/no-var-requires
        const schema = require(path.join(__dirname, './fixtures/test-nested-object-array.json'));
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const content = `objA:
  - name: nameA1
      
objB:
  size: midle
  name: nameB2  
`; // len: 67
        const completion = await parseSetup(content, 2, 4);
        (0, chai_1.expect)(completion.items).is.not.empty;
    });
    it('should complete array item for "oneOf" schema', async () => {
        // eslint-disable-next-line @typescript-eslint/no-var-requires
        const schema = require(path.join(__dirname, './fixtures/test-completion-oneOf.json'));
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const content = `metadata:
  Selector:
    query:
      - 
`; // len: 42
        const completion = await parseSetup(content, 3, 8);
        (0, chai_1.expect)(completion.items).length(5);
        (0, chai_1.expect)(completion.items.map((it) => it.label)).to.have.members(['NOT', 'attribute', 'operation', 'value', 'FUNC_item']);
    });
    it('Autocomplete with short nextLine - nested object', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'object',
            properties: {
                example: {
                    type: 'object',
                    properties: {
                        sample: {
                            type: 'object',
                            properties: {
                                detail: {
                                    type: 'object',
                                },
                            },
                        },
                    },
                },
                a: {
                    type: 'string',
                    description: 'short prop name because of distance to the cursor',
                },
            },
        });
        const content = 'example:\n  sample:\n    '; // len: 23
        const completion = await parseSetup(content + '\na: test', 2, 4);
        (0, chai_1.expect)(completion.items.length).equal(1);
        (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('detail', 'detail:\n  ', 2, 4, 2, 4, 10, 2, {
            documentation: '',
        }));
    });
    it('Should suggest valid matches from oneOf', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            oneOf: [
                {
                    type: 'object',
                    properties: {
                        spec: {
                            type: 'object',
                        },
                    },
                },
                {
                    properties: {
                        spec: {
                            type: 'object',
                            required: ['bar'],
                            properties: {
                                bar: {
                                    type: 'string',
                                },
                            },
                        },
                    },
                },
            ],
        });
        const content = '|s|'; // len: 1, pos: 1
        const completion = await parseCaret(content);
        (0, chai_1.expect)(completion.items.length).equal(1);
        (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('spec', 'spec:\n  bar: ', 0, 0, 0, 1, 10, 2, {
            documentation: '',
        }));
    });
    it('Should suggest all the matches from allOf', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            allOf: [
                {
                    type: 'object',
                    properties: {
                        spec: {
                            type: 'object',
                        },
                    },
                },
                {
                    properties: {
                        spec: {
                            type: 'object',
                            required: ['bar'],
                            properties: {
                                bar: {
                                    type: 'string',
                                },
                            },
                        },
                    },
                },
            ],
        });
        const content = '|s|'; // len: 1, pos: 1
        const completion = await parseCaret(content);
        (0, chai_1.expect)(completion.items.length).equal(2);
        (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('spec', 'spec:\n  ', 0, 0, 0, 1, 10, 2, {
            documentation: '',
        }));
        (0, chai_1.expect)(completion.items[1]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('spec', 'spec:\n  bar: ', 0, 0, 0, 1, 10, 2, {
            documentation: '',
        }));
    });
    it('Autocomplete with a new line inside the object', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'object',
            properties: {
                example: {
                    type: 'object',
                    properties: {
                        sample: {
                            type: 'object',
                            properties: {
                                prop1: {
                                    type: 'string',
                                },
                                prop2: {
                                    type: 'string',
                                },
                            },
                        },
                    },
                },
            },
        });
        const content = 'example:\n  sample:\n    |\n|    prop2: value2'; // len: 41, pos: 23
        const completion = await parseCaret(content);
        (0, chai_1.expect)(completion.items.length).equal(1);
        (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('prop1', 'prop1: ', 2, 4, 2, 4, 10, 2, {
            documentation: '',
        }));
    });
    it('Autocomplete on the first array item', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'object',
            properties: {
                examples: {
                    type: 'array',
                    items: {
                        type: 'object',
                        properties: {
                            sample: {
                                type: 'object',
                                properties: {
                                    prop1: {
                                        type: 'string',
                                    },
                                },
                            },
                        },
                    },
                },
            },
        });
        const content = 'examples:\n  |\n|  - sample:\n      prop1: value1'; // len: 44, pos: 12
        const completion = await parseCaret(content);
        (0, chai_1.expect)(completion.items.length).equal(1);
        (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('- (array item) object', '- ', 1, 2, 1, 2, 9, 2, {
            documentation: {
                kind: 'markdown',
                value: 'Create an item of an array type `object`\n ```\n- \n```',
            },
        }));
    });
    it('Array of enum autocomplete of irregular order', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'object',
            properties: {
                apiVersion: {
                    type: 'string',
                },
                metadata: {
                    type: 'object',
                    properties: {
                        name: {
                            type: 'string',
                        },
                    },
                },
                kind: {
                    type: 'string',
                    enum: ['Pod', 'PodTemplate'],
                },
            },
        });
        const content = 'kind: Po'; // len: 8
        const completion = await parseSetup(content, 1, 9);
        (0, chai_1.expect)(completion.items.length).equal(2);
        (0, chai_1.expect)(completion.items[0].insertText).equal('Pod');
        (0, chai_1.expect)(completion.items[1].insertText).equal('PodTemplate');
    });
    it('Test that properties have enum of string type with number', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'object',
            properties: {
                version: {
                    type: 'array',
                    items: {
                        enum: ['12.1', 13, '13.1', '14.0', 'all', 14.4, false, null, ['test']],
                        type: ['string', 'integer', 'number', 'boolean', 'object', 'array'],
                    },
                },
            },
        });
        const content = 'version:\n  - ';
        const completion = await parseSetup(content, 2, 0);
        (0, chai_1.expect)(completion.items).lengthOf(9);
        (0, chai_1.expect)(completion.items[0].insertText).equal('"12.1"');
        (0, chai_1.expect)(completion.items[1].insertText).equal('13');
        (0, chai_1.expect)(completion.items[4].insertText).equal('all');
        (0, chai_1.expect)(completion.items[5].insertText).equal('14.4');
        (0, chai_1.expect)(completion.items[6].insertText).equal('false');
        (0, chai_1.expect)(completion.items[7].insertText).equal('null');
        (0, chai_1.expect)(completion.items[8].insertText).equal('\n  - ${1:test}\n');
    });
    it('Autocomplete indent on array when parent is array', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'object',
            properties: {
                examples: {
                    type: 'array',
                    items: {
                        type: 'object',
                        properties: {
                            objectWithArray: {
                                type: 'array',
                                items: {
                                    type: 'string',
                                },
                            },
                        },
                    },
                },
            },
        });
        const content = 'examples:\n  - '; // len: 14
        const completion = await parseSetup(content, 1, 4);
        (0, chai_1.expect)(completion.items.length).equal(1);
        (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('objectWithArray', 'objectWithArray:\n    - ${1}', 1, 4, 1, 4, 10, 2, {
            documentation: '',
        }));
    });
    it('Autocomplete indent on array object when parent is array', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'object',
            properties: {
                examples: {
                    type: 'array',
                    items: {
                        type: 'object',
                        properties: {
                            objectWithArray: {
                                type: 'array',
                                items: {
                                    type: 'object',
                                    required: ['item', 'item2'],
                                    properties: {
                                        item: { type: 'string' },
                                        item2: { type: 'string' },
                                    },
                                },
                            },
                        },
                    },
                },
            },
        });
        const content = 'examples:\n  - '; // len: 14
        const completion = await parseSetup(content, 1, 4);
        (0, chai_1.expect)(completion.items.length).equal(1);
        (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('objectWithArray', 'objectWithArray:\n    - item: $1\n      item2: $2', 1, 4, 1, 4, 10, 2, {
            documentation: '',
        }));
    });
    it('Autocomplete indent on array object when parent is array of an array', async () => {
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
            type: 'object',
            properties: {
                array1: {
                    type: 'array',
                    items: {
                        type: 'object',
                        required: ['thing1'],
                        properties: {
                            thing1: {
                                type: 'object',
                                required: ['array2'],
                                properties: {
                                    array2: {
                                        type: 'array',
                                        items: {
                                            type: 'object',
                                            required: ['thing2', 'type'],
                                            properties: {
                                                type: {
                                                    type: 'string',
                                                },
                                                thing2: {
                                                    type: 'object',
                                                    required: ['item1', 'item2'],
                                                    properties: {
                                                        item1: { type: 'string' },
                                                        item2: { type: 'string' },
                                                    },
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            },
        });
        const content = 'array1:\n  - ';
        const completion = await parseSetup(content, 1, 4);
        (0, chai_1.expect)(completion.items[0].insertText).to.be.equal('thing1:\n    array2:\n      - type: $1\n        thing2:\n          item1: $2\n          item2: $3');
    });
    describe('array indent on different index position', () => {
        const schema = {
            type: 'object',
            properties: {
                objectWithArray: {
                    type: 'array',
                    items: {
                        type: 'object',
                        required: ['item', 'item2'],
                        properties: {
                            item: { type: 'string' },
                            item2: {
                                type: 'object',
                                required: ['prop1', 'prop2'],
                                properties: {
                                    prop1: { type: 'string' },
                                    prop2: { type: 'string' },
                                },
                            },
                        },
                    },
                },
            },
        };
        it('array indent on the first item', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'objectWithArray:\n  - '; // len: 21
            const completion = await parseSetup(content, 1, 4);
            (0, chai_1.expect)(completion.items.length).equal(3);
            (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('item', 'item: ', 1, 4, 1, 4, 10, 2, {
                documentation: '',
            }));
            (0, chai_1.expect)(completion.items[2]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('item2', 'item2:\n    prop1: $1\n    prop2: $2', 1, 4, 1, 4, 10, 2, {
                documentation: '',
            }));
        });
        it('array indent on the second item', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'objectWithArray:\n  - item: first line\n    '; // len: 42
            const completion = await parseSetup(content, 2, 4);
            (0, chai_1.expect)(completion.items.length).equal(2);
            (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('item2', 'item2:\n  prop1: $1\n  prop2: $2', 2, 4, 2, 4, 10, 2, {
                documentation: '',
            }));
        });
    });
    describe('merge properties from anyOf objects', () => {
        it('should merge different simple values', async () => {
            const schema = {
                anyOf: [
                    {
                        properties: {
                            simplePropWithSimpleValue: { type: 'string', const: 'const value' },
                        },
                    },
                    {
                        properties: {
                            simplePropWithSimpleValue: { type: 'boolean', default: false },
                        },
                    },
                    {
                        properties: {
                            simplePropWithSimpleValue: { type: 'null', default: null },
                        },
                    },
                    {
                        properties: {
                            simplePropWithSimpleValue: { type: 'string' },
                        },
                    },
                ],
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = '';
            const completion = await parseSetup(content, 0, 1);
            (0, chai_1.expect)(completion.items.length).equal(1);
            (0, chai_1.expect)(completion.items[0].insertText).to.be.equal('simplePropWithSimpleValue: ${1|const value,false,null|}');
        });
        it('should autocomplete as single item with same value', async () => {
            const schema = {
                anyOf: [
                    {
                        properties: {
                            simplePropWithSameValue: { type: 'string', const: 'const value 1' },
                            obj1: { properties: { prop1: { type: 'string' } } },
                        },
                    },
                    {
                        properties: {
                            simplePropWithSameValue: { type: 'string', const: 'const value 1' },
                            obj1: { properties: { prop1: { type: 'string' } } },
                        },
                    },
                ],
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = '';
            const completion = await parseSetup(content, 0, 1);
            (0, chai_1.expect)(completion.items.length).equal(2);
            (0, chai_1.expect)(completion.items[0].insertText).to.be.equal('simplePropWithSameValue: const value 1');
            (0, chai_1.expect)(completion.items[1].insertText).to.be.equal('obj1:\n  ');
        });
        it('should not merge objects', async () => {
            const schema = {
                anyOf: [
                    {
                        properties: {
                            obj1: { properties: { prop1: { type: 'string' } }, required: ['prop1'] },
                        },
                    },
                    {
                        properties: {
                            obj1: { properties: { prop2: { type: 'string', const: 'value' } }, required: ['prop2'] },
                        },
                    },
                ],
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = '';
            const completion = await parseSetup(content, 0, 1);
            (0, chai_1.expect)(completion.items.length).equal(2);
            (0, chai_1.expect)(completion.items[0].label).to.be.equal('obj1');
            (0, chai_1.expect)(completion.items[0].insertText).to.be.equal('obj1:\n  prop1: ');
            (0, chai_1.expect)(completion.items[1].label).to.be.equal('obj1');
            (0, chai_1.expect)(completion.items[1].insertText).to.be.equal('obj1:\n  prop2: ${1:value}');
        });
        it('Autocomplete should not suggest items for parent object', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
                type: 'object',
                properties: {
                    scripts: {
                        type: 'object',
                        properties: {
                            sample: {
                                type: 'string',
                            },
                        },
                    },
                    scripts2: {
                        type: 'string',
                    },
                },
            });
            const content = 'scripts:   \n  sample: | |';
            const completion = await parseSetup(content, 0, 9); // before line brake
            (0, chai_1.expect)(completion.items.length).equal(0);
        });
        it('autoCompletion when value is null inside anyOf object', async () => {
            const schema = {
                anyOf: [
                    {
                        properties: {
                            prop: {
                                const: 'const value',
                            },
                        },
                    },
                    {
                        properties: {
                            prop: {
                                type: 'null',
                            },
                        },
                    },
                ],
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = '';
            const completion = await parseSetup(content, 0, 6);
            (0, chai_1.expect)(completion.items.length).equal(1);
            (0, chai_1.expect)(completion.items[0].label).to.be.equal('prop');
            (0, chai_1.expect)(completion.items[0].insertText).to.be.equal('prop: ${1|const value,null|}');
        });
        it('should take all sub-schemas when value has not been set (cursor in the middle of the empty space)', async () => {
            const schema = {
                anyOf: [
                    {
                        properties: {
                            prop: { type: 'null' },
                        },
                    },
                    {
                        properties: {
                            prop: { const: 'const value' },
                        },
                    },
                    {
                        properties: {
                            prop: { const: 5 },
                        },
                    },
                ],
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'prop: | | ';
            const completion = await parseCaret(content);
            (0, chai_1.expect)(completion.items.map((i) => i.label)).to.be.deep.eq(['const value', '5', 'null']);
        });
        it('should take only null sub-schema when value is "null"', async () => {
            const schema = {
                anyOf: [
                    {
                        properties: {
                            prop: { type: 'null' },
                        },
                    },
                    {
                        properties: {
                            prop: { const: 'const value' },
                        },
                    },
                ],
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'prop: null';
            const completion = await parseSetup(content, 0, content.length);
            (0, chai_1.expect)(completion.items.map((i) => i.label)).to.be.deep.eq(['null']);
        });
        it('should take only one sub-schema because first sub-schema does not match', async () => {
            const schema = {
                anyOf: [
                    {
                        properties: {
                            prop: { const: 'const value' },
                        },
                    },
                    {
                        properties: {
                            prop: { const: 'const value2' },
                        },
                    },
                ],
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'prop: const value2';
            const completion = await parseSetup(content, 0, content.length);
            (0, chai_1.expect)(completion.items.map((i) => i.label)).to.be.deep.eq(['const value2']);
        });
        it('should match only second sub-schema because the first one does not match', async () => {
            const schema = {
                anyOf: [
                    {
                        properties: {
                            prop: {
                                const: 'typeA',
                            },
                            propA: {},
                        },
                    },
                    {
                        properties: {
                            prop: {
                                const: 'typeB',
                            },
                            propB: {},
                        },
                    },
                ],
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'prop: typeB\n|\n|';
            const completion = await parseCaret(content);
            (0, chai_1.expect)(completion.items.map((i) => i.label)).to.be.deep.eq(['propB']);
        });
        it('should suggest from all sub-schemas even if nodes properties match better other schema', async () => {
            // this is a case when we have a better match in the second schema but we should still suggest from the first one
            // it works because `prop: ` will evaluate to `enumValueMatch = true` for both schemas
            const schema = {
                anyOf: [
                    {
                        properties: {
                            prop: {
                                const: 'typeA',
                            },
                        },
                    },
                    {
                        properties: {
                            prop: {
                                const: 'typeB',
                            },
                            propB: {},
                        },
                    },
                ],
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'prop: |\n|\npropB: B';
            const completion = await parseCaret(content);
            (0, chai_1.expect)(completion.items.map((i) => i.label)).to.be.deep.eq(['typeA', 'typeB'], 'with null value');
            const content2 = 'prop: typ|\n|\npropB: B';
            const completion2 = await parseCaret(content2);
            (0, chai_1.expect)(completion2.items.map((i) => i.label)).to.be.deep.eq(['typeA', 'typeB'], 'with prefix value');
        });
        it('should suggest both sub-schemas for anyof array', async () => {
            const schema = {
                properties: {
                    entities: {
                        type: 'array',
                        items: {
                            anyOf: [
                                {
                                    enum: ['enum1'],
                                },
                                {
                                    type: 'object',
                                    title: 'entity object',
                                    properties: {
                                        entityProp: { type: 'string' },
                                    },
                                    required: ['entityProp'],
                                },
                            ],
                        },
                    },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'entities:\n  - |\n|';
            const completion = await parseCaret(content);
            (0, chai_1.expect)(completion.items.map((i) => i.label)).to.be.deep.eq(['enum1', 'entityProp', 'entity object']);
        });
    });
    describe('extra space after cursor', () => {
        it('simple const', async () => {
            const schema = {
                properties: {
                    prop: {
                        const: 'const',
                    },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'prop: | | '; // len: 8, pos: 6
            const completion = await parseCaret(content);
            (0, chai_1.expect)(completion.items.length).equal(1);
            (0, chai_1.expect)(completion.items[0].label).to.be.equal('const');
            (0, chai_1.expect)(completion.items[0].textEdit).to.be.deep.equal({ newText: 'const', range: vscode_languageserver_types_1.Range.create(0, 6, 0, 8) });
        });
        it('partial key with trailing spaces', async () => {
            const schema = {
                properties: {
                    name: {
                        const: 'my name',
                    },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'na  ';
            const completion = await parseSetup(content, 0, 2);
            (0, chai_1.expect)(completion.items.length).equal(1);
            (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('name', 'name: my name', 0, 0, 0, 4, 10, 2, {
                documentation: '',
            }));
        });
        it('partial key with trailing spaces with new line', async () => {
            const schema = {
                properties: {
                    name: {
                        const: 'my name',
                    },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'na  \n';
            const completion = await parseSetup(content, 0, 2);
            (0, chai_1.expect)(completion.items.length).equal(1);
            (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('name', 'name: my name', 0, 0, 0, 5, 10, 2, {
                documentation: '',
            }));
        });
        it('partial key with leading and trailing spaces', async () => {
            const schema = {
                properties: {
                    name: {
                        const: 'my name',
                    },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = '  na  ';
            const completion = await parseSetup(content, 0, 2);
            (0, chai_1.expect)(completion.items.length).equal(1);
            (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('name', 'name: my name', 0, 2, 0, 4, 10, 2, {
                documentation: '',
            }));
        });
        it('partial key with trailing spaces with special chars inside the array', async () => {
            const schema = {
                type: 'object',
                properties: {
                    array: {
                        type: 'array',
                        items: {
                            type: 'object',
                            properties: {
                                'name / 123': {
                                    const: 'my name',
                                },
                            },
                        },
                    },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'array:\n - name /   ';
            const completion = await parseSetup(content, 1, 9);
            (0, chai_1.expect)(completion.items.length).equal(1);
            (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('name / 123', 'name / 123: my name', 1, 3, 1, 12, 10, 2, {
                documentation: '',
            }));
        });
        describe('partial value with trailing spaces', () => {
            it('partial value with trailing spaces', async () => {
                const schema = {
                    properties: {
                        name: {
                            const: 'my name',
                        },
                    },
                };
                schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
                const content = 'name: my| |   ';
                const completion = await parseCaret(content);
                (0, chai_1.expect)(completion.items.length).equal(1);
                (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('my name', 'my name', 0, 6, 0, 12, 12, 2, {
                    documentation: undefined,
                }));
            });
            it('partial value with trailing spaces with new line', async () => {
                const schema = {
                    properties: {
                        name: {
                            const: 'my name',
                        },
                    },
                };
                schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
                const content = 'name: my| |   \n';
                const completion = await parseCaret(content);
                (0, chai_1.expect)(completion.items.length).equal(1);
                (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('my name', 'my name', 0, 6, 0, 13, 12, 2, {
                    documentation: undefined,
                }));
            });
            it('partial value with leading and trailing spaces', async () => {
                const schema = {
                    properties: {
                        name: {
                            const: 'my name',
                        },
                    },
                };
                schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
                const content = 'name:   my na| |   ';
                const completion = await parseCaret(content);
                (0, chai_1.expect)(completion.items.length).equal(1);
                (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('my name', 'my name', 0, 6, 0, 17, 12, 2, {
                    documentation: undefined,
                }));
            });
            it('partial value with trailing spaces with special chars inside the array', async () => {
                const schema = {
                    type: 'object',
                    properties: {
                        array: {
                            type: 'array',
                            items: {
                                type: 'object',
                                properties: {
                                    name: {
                                        const: 'my name / 123',
                                    },
                                },
                            },
                        },
                    },
                };
                schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
                const content = 'array:\n - name: my name /| |  ';
                const completion = await parseCaret(content);
                (0, chai_1.expect)(completion.items.length).equal(1);
                (0, chai_1.expect)(completion.items[0]).eql((0, verifyError_1.createExpectedCompletion)('my name / 123', 'my name / 123', 1, 9, 1, 21, 12, 2, {
                    documentation: undefined,
                }));
            });
        });
        it('object - 2nd nested property', async () => {
            const schema = {
                properties: {
                    parent: {
                        properties: {
                            prop1: {
                                const: 'const1',
                            },
                            prop2: {
                                const: 'const2',
                            },
                        },
                    },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'parent:\n  prop1: const1\n  prop2:   ';
            const completion = await parseSetup(content, 2, 9);
            (0, chai_1.expect)(completion.items.length).equal(1);
            (0, chai_1.expect)(completion.items[0].label).to.be.equal('const2');
            (0, chai_1.expect)(completion.items[0].textEdit).to.be.deep.equal({
                newText: 'const2',
                range: vscode_languageserver_types_1.Range.create(2, 9, 2, 11),
            });
        });
        it('array - 2nd nested property', async () => {
            const schema = {
                properties: {
                    arrayObj: {
                        type: 'array',
                        items: {
                            type: 'object',
                            properties: {
                                item1: {
                                    type: 'string',
                                },
                                item2: {
                                    const: 'const2',
                                },
                            },
                            required: ['item1', 'item2'],
                        },
                    },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'arrayObj:\n  - item1: test\n  - item2:   ';
            const completion = await parseSetup(content, 2, 11);
            (0, chai_1.expect)(completion.items.length).equal(1);
            (0, chai_1.expect)(completion.items[0].label).to.be.equal('const2');
            (0, chai_1.expect)(completion.items[0].textEdit).to.be.deep.equal({
                newText: 'const2',
                range: vscode_languageserver_types_1.Range.create(2, 11, 2, 13),
            });
        });
        describe('array object item', () => {
            const schema = {
                properties: {
                    arrayObj: {
                        type: 'array',
                        items: {
                            type: 'object',
                            properties: {
                                item1: {
                                    type: 'string',
                                },
                                item2: {
                                    type: 'string',
                                },
                            },
                            required: ['item1', 'item2'],
                        },
                    },
                },
            };
            it('1st item', async () => {
                schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
                const content = 'arrayObj:\n  -   ';
                const completion = await parseSetup(content, 1, 4);
                (0, chai_1.expect)(completion.items.length).equal(3);
                (0, chai_1.expect)(completion.items[1].textEdit).to.be.deep.equal({
                    newText: 'item1: $1\n  item2: $2',
                    range: vscode_languageserver_types_1.Range.create(1, 4, 1, 6), // removes extra spaces after cursor
                });
            });
            it('next item', async () => {
                schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
                const content = 'arrayObj:\n  - item1: a\n  - item2: b\n  -   ';
                const completion = await parseSetup(content, 3, 4);
                (0, chai_1.expect)(completion.items.length).equal(3);
                (0, chai_1.expect)(completion.items[1].textEdit).to.be.deep.equal({
                    newText: 'item1: $1\n  item2: $2',
                    range: vscode_languageserver_types_1.Range.create(3, 4, 3, 6), // removes extra spaces after cursor
                });
            });
        });
        it('array completion - should suggest correct indent when extra spaces after cursor', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
                type: 'object',
                properties: {
                    test: {
                        type: 'array',
                        items: {
                            type: 'object',
                            properties: {
                                objA: {
                                    type: 'object',
                                    required: ['itemA'],
                                    properties: {
                                        itemA: {
                                            type: 'string',
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            });
            const content = 'test:\n  -               ';
            const result = await parseSetup(content, 1, 4);
            (0, chai_1.expect)(result.items.length).to.be.equal(1);
            (0, chai_1.expect)(result.items[0].insertText).to.be.equal('objA:\n    itemA: ');
        });
        it('array of arrays completion - should suggest correct indent when extra spaces after cursor', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
                type: 'object',
                properties: {
                    array1: {
                        type: 'array',
                        items: {
                            type: 'object',
                            required: ['array2'],
                            properties: {
                                array2: {
                                    type: 'array',
                                    items: {
                                        type: 'object',
                                        required: ['objA'],
                                        properties: {
                                            objA: {
                                                type: 'object',
                                                required: ['itemA'],
                                                properties: {
                                                    itemA: {
                                                        type: 'string',
                                                    },
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            });
            const content = 'array1:\n  -               ';
            const result = await parseSetup(content, 1, 4);
            (0, chai_1.expect)(result.items.length).to.be.equal(2);
            (0, chai_1.expect)(result.items[0].insertText).to.be.equal('array2:\n    - objA:\n        itemA: ');
        });
        it('object of array of arrays completion - should suggest correct indent when extra spaces after cursor', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, {
                type: 'object',
                properties: {
                    array1: {
                        type: 'array',
                        items: {
                            type: 'object',
                            properties: {
                                array2: {
                                    type: 'array',
                                    items: {
                                        type: 'object',
                                        properties: {
                                            objA: {
                                                type: 'object',
                                                required: ['itemA'],
                                                properties: {
                                                    itemA: {
                                                        type: 'string',
                                                    },
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            });
            const content = 'array1:\n  - array2:\n      -               ';
            const result = await parseSetup(content, 2, 8);
            (0, chai_1.expect)(result.items.length).to.be.equal(1);
            (0, chai_1.expect)(result.items[0].insertText).to.be.equal('objA:\n    itemA: ');
        });
    }); //'extra space after cursor'
    it('should suggest from additionalProperties', async () => {
        const schema = {
            type: 'object',
            additionalProperties: {
                anyOf: [
                    {
                        type: 'string',
                        const: 'test1',
                    },
                ],
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const content = 'value: ';
        const completion = await parseSetup(content, 0, content.length);
        (0, chai_1.expect)(completion.items.length).equal(1);
        (0, chai_1.expect)(completion.items[0].insertText).to.be.equal('test1');
    });
    it('should suggest defaultSnippets from additionalProperties', async () => {
        const schema = {
            type: 'object',
            properties: {
                id: {
                    type: 'string',
                },
            },
            additionalProperties: {
                anyOf: [
                    {
                        type: 'string',
                        defaultSnippets: [{ label: 'snippet', body: 'snippetBody' }],
                    },
                ],
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const content = 'value: |\n|';
        const completion = await parseCaret(content);
        (0, chai_1.expect)(completion.items.map((i) => i.insertText)).to.be.deep.equal(['snippetBody']);
    });
    describe('should suggest prop of the object (based on not completed prop name)', () => {
        const schema = {
            definitions: {
                Obj: {
                    anyOf: [
                        { type: 'string' },
                        {
                            type: 'object',
                            properties: {
                                prop1: { type: 'string' },
                            },
                            required: ['prop1'],
                        },
                    ],
                },
            },
            properties: {
                test1: {
                    properties: {
                        nested: { $ref: '#/definitions/Obj' },
                    },
                },
                test2: { $ref: '#/definitions/Obj' },
            },
        };
        const content = `
test2: 
  pr
test1:
  nested: 
    pr
`;
        it('nested object', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const completion = await parseSetup(content, 5, 6);
            (0, chai_1.expect)(completion.items.length).equal(2);
            (0, chai_1.expect)(completion.items[0].label).to.be.equal('prop1');
        });
        it('root object', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const completion = await parseSetup(content, 2, 4);
            (0, chai_1.expect)(completion.items.length).equal(2);
            (0, chai_1.expect)(completion.items[0].label).to.be.equal('prop1');
        });
    });
    describe('should suggest property before indented comment', () => {
        const schema = {
            type: 'object',
            properties: {
                example: {
                    type: 'object',
                    properties: {
                        prop1: {
                            type: 'string',
                        },
                        prop2: {
                            type: 'string',
                        },
                        prop3: {
                            type: 'string',
                        },
                    },
                },
            },
        };
        it('completion should handle indented comment on new line', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'example:\n  prop1: "test"\n  \n    #comment';
            const completion = await parseSetup(content, 2, 2);
            (0, chai_1.expect)(completion.items.length).equal(2);
            (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('prop2', 'prop2: ', 2, 2, 2, 2, vscode_languageserver_types_1.CompletionItemKind.Property, vscode_languageserver_types_1.InsertTextFormat.Snippet, {
                documentation: '',
            }));
        });
        it('completion should handle comment at same indent level on new line', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'example:\n  prop1: "test"\n  \n  #comment';
            const completion = await parseSetup(content, 2, 2);
            (0, chai_1.expect)(completion.items.length).equal(2);
            (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('prop2', 'prop2: ', 2, 2, 2, 2, vscode_languageserver_types_1.CompletionItemKind.Property, vscode_languageserver_types_1.InsertTextFormat.Snippet, {
                documentation: '',
            }));
        });
        it('completion should handle suggestion without comment on next line', async () => {
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
            const content = 'example:\n  prop1: "test"\n  \n  prop3: "test"';
            const completion = await parseSetup(content, 2, 2);
            (0, chai_1.expect)(completion.items.length).equal(1);
            (0, chai_1.expect)(completion.items[0]).to.be.deep.equal((0, verifyError_1.createExpectedCompletion)('prop2', 'prop2: ', 2, 2, 2, 2, vscode_languageserver_types_1.CompletionItemKind.Property, vscode_languageserver_types_1.InsertTextFormat.Snippet, {
                documentation: '',
            }));
        });
    });
    it('should suggest property of unknown object', async () => {
        const schema = {
            type: 'object',
            additionalProperties: true,
            propertyNames: {
                title: 'property',
                description: 'Property Description',
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const content = '';
        const completion = await parseSetup(content, 0, content.length);
        (0, chai_1.expect)(completion.items.length).equal(1);
        (0, chai_1.expect)(completion.items[0].insertText).to.be.equal('${1:property}: ');
        (0, chai_1.expect)(completion.items[0].documentation).to.be.deep.equal({ kind: 'markdown', value: 'Property Description' });
    });
    it('should not suggest propertyNames with doNotSuggest', async () => {
        const schema = {
            type: 'object',
            additionalProperties: true,
            propertyNames: {
                title: 'property',
                doNotSuggest: true,
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const content = '';
        const completion = await parseSetup(content, 0, content.length);
        (0, chai_1.expect)(completion.items.length).equal(0);
    });
    it('should suggest enum based on type', async () => {
        const schema = {
            type: 'object',
            additionalProperties: false,
            properties: {
                test: {
                    type: 'string',
                    enum: ['YES', 'NO'],
                },
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const content = 'test: ';
        const completion = await parseSetup(content, 0, content.length);
        (0, chai_1.expect)(completion.items.length).equal(2);
        (0, chai_1.expect)(completion.items[0].insertText).to.be.equal('"YES"');
        (0, chai_1.expect)(completion.items[1].insertText).to.be.equal('"NO"');
    });
    it('should suggest propertyNames keys from definitions $ref', async () => {
        const schema = {
            definitions: {
                EventName: {
                    type: 'string',
                    title: 'EventName',
                    enum: ['None', 'Event1', 'Event2'],
                },
            },
            type: 'object',
            properties: {
                events: {
                    type: 'object',
                    propertyNames: { $ref: '#/definitions/EventName' },
                },
            },
            required: ['events'],
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const completion = await parseSetup('events:\n  ', 1, 2);
        (0, chai_1.expect)(completion.items.map((i) => i.label)).to.have.members(['None', 'Event1', 'Event2']);
    });
    it('should suggest propertyNames candidates from const', async () => {
        const schema = {
            type: 'object',
            propertyNames: {
                const: 'Event0',
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const completion = await parseSetup('', 0, 0);
        (0, chai_1.expect)(completion.items.map((i) => i.label)).to.have.members(['Event0']);
    });
    it('should suggest propertyNames candidates from enum', async () => {
        const schema = {
            type: 'object',
            additionalProperties: true,
            propertyNames: {
                enum: ['Event1', 'Event2', 'Event3'],
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const completion = await parseSetup('', 0, 0);
        (0, chai_1.expect)(completion.items.map((i) => i.label)).to.have.members(['Event1', 'Event2', 'Event3']);
    });
    it('should suggest propertyNames candidates from oneOf', async () => {
        const schema = {
            type: 'object',
            propertyNames: {
                oneOf: [{ const: 'Event1' }, { const: 'Event2' }],
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const completion = await parseSetup('', 0, 0);
        (0, chai_1.expect)(completion.items.map((i) => i.label)).to.have.members(['Event1', 'Event2']);
    });
    it('should suggest propertyNames candidates from anyOf', async () => {
        const schema = {
            type: 'object',
            propertyNames: {
                anyOf: [{ const: 'Event1' }, { enum: ['Event2', 'Event3'] }],
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const completion = await parseSetup('', 0, 0);
        (0, chai_1.expect)(completion.items.map((i) => i.label)).to.have.members(['Event1', 'Event2', 'Event3']);
    });
    it('should suggest only the intersected propertyNames candidate from allOf (const + enum)', async () => {
        const schema = {
            type: 'object',
            propertyNames: {
                allOf: [{ const: 'One' }, { enum: ['One', 'Two'] }],
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const completion = await parseSetup('', 0, 0);
        (0, chai_1.expect)(completion.items.map((i) => i.label)).to.have.members(['One']);
        (0, chai_1.expect)(completion.items.map((i) => i.label)).to.not.include('Two');
    });
    it('should not suggest any propertyNames when allOf makes keys impossible (const + const)', async () => {
        const schema = {
            type: 'object',
            propertyNames: {
                allOf: [{ const: 'One' }, { const: 'Two' }],
            },
        };
        schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        const completion = await parseSetup('', 0, 0);
        (0, chai_1.expect)(completion.items).to.be.empty;
    });
    describe('String scalar completion comprehensive tests', () => {
        const STRING_CASES = [
            { value: '', expected: '""', description: 'empty string' },
            { value: '""', expected: '"\\"\\""', description: 'literal double quotes' },
            { value: "''", expected: `"''"`, description: 'literal single quotes' },
            { value: '"', expected: '"\\""', description: 'single quote character' },
            { value: "'", expected: '"\'"', description: 'single apostrophe' },
            { value: 'a: b', expected: '"a: b"', description: 'string with colon and space' },
            { value: '# not a comment', expected: '"# not a comment"', description: 'string starting with hash' },
            { value: '- starts with dash', expected: '"- starts with dash"', description: 'string starting with dash' },
            {
                value: '? starts with question',
                expected: '"? starts with question"',
                description: 'string starting with question mark',
            },
            { value: 'null', expected: '"null"', description: 'string "null"' },
            { value: '123', expected: '"123"', description: 'numeric string' },
            { value: '  leading space', expected: '"  leading space"', description: 'string with leading spaces' },
            { value: 'trailing space ', expected: '"trailing space "', description: 'string with trailing space' },
            {
                value: 'line1\n\tline2',
                expected: '"line1\\n\\tline2"',
                expectedLabel: '"line1↵\\tline2"',
                description: 'string with newline and tab',
            },
            { value: 'endsWithColon:', expected: '"endsWithColon:"', description: 'string ending with colon' },
            { value: '0xdeadbeef', expected: '"0xdeadbeef"', description: 'hex-like string' },
            { value: '01', expected: '"01"', description: 'octal-like string' },
            { value: '0o12', expected: '"0o12"', description: 'octal-like string with prefix' },
            { value: '\\"', expected: '"\\\\\\\\\\""', description: 'backslash-quote' },
        ];
        const addEnumSchema = (value) => {
            const schema = {
                type: 'object',
                additionalProperties: false,
                properties: {
                    testProp: {
                        type: 'string',
                        enum: [value],
                    },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        };
        describe('Enum', () => {
            STRING_CASES.forEach(({ value, expected, description }) => {
                describe(description, () => {
                    beforeEach(() => addEnumSchema(value));
                    it('should handle enum key value', async () => {
                        const content = '';
                        const completion = await parseSetup(content, 0, content.length);
                        (0, chai_1.expect)(completion.items.length).to.equal(1);
                        (0, chai_1.expect)(completion.items[0].insertText).to.equal(`testProp: \${1:${expected}}`);
                    });
                    it('should handle enum value after property name', async () => {
                        const content = 'testProp: ';
                        const completion = await parseSetup(content, 0, content.length);
                        (0, chai_1.expect)(completion.items.length).to.equal(1);
                        (0, chai_1.expect)(completion.items[0].insertText).to.equal(expected);
                    });
                });
            });
        });
        const addConstSchema = (value) => {
            const schema = {
                type: 'object',
                additionalProperties: false,
                properties: {
                    testProp: {
                        type: 'string',
                        const: value,
                    },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        };
        describe('Const', () => {
            STRING_CASES.forEach(({ value, expected, expectedLabel, description }) => {
                describe(description, () => {
                    beforeEach(() => addConstSchema(value));
                    it('should handle const key value', async () => {
                        const content = 'test';
                        const completion = await parseSetup(content, 0, content.length);
                        (0, chai_1.expect)(completion.items.length).to.equal(1);
                        (0, chai_1.expect)(completion.items[0].insertText).to.equal(`testProp: ${expected}`);
                    });
                    it('should handle const value after property name', async () => {
                        const content = 'testProp: ';
                        const completion = await parseSetup(content, 0, content.length);
                        (0, chai_1.expect)(completion.items.length).to.be.greaterThan(0);
                        (0, chai_1.expect)(completion.items[0].insertText).to.equal(expected);
                        // Only assert label when we expect it to differ (e.g., newline rendering)
                        if (expectedLabel !== undefined) {
                            (0, chai_1.expect)(completion.items[0].label).to.equal(expectedLabel);
                        }
                    });
                });
            });
        });
        const addPropertyNameSchema = (propName) => {
            const schema = {
                type: 'object',
                additionalProperties: false,
                properties: {
                    [propName]: { type: 'string' },
                },
            };
            schemaProvider.addSchema(testHelper_1.SCHEMA_ID, schema);
        };
        describe('Property name (key)', () => {
            STRING_CASES.filter(({ value }) => value !== '').forEach(({ value, expected, description }) => {
                describe(description, () => {
                    beforeEach(() => addPropertyNameSchema(value));
                    it('should handle property name completion', async () => {
                        const content = '';
                        const completion = await parseSetup(content, 0, content.length);
                        (0, chai_1.expect)(completion.items.length).to.equal(1);
                        (0, chai_1.expect)(completion.items[0].insertText).to.equal(`${expected}: `);
                    });
                });
            });
        });
    });
});
//# sourceMappingURL=autoCompletionFix.test.js.map