diff --git a/src/creator/cShaprFileCreator.ts b/src/creator/cShaprFileCreator.ts index 08fb670..86d4570 100644 --- a/src/creator/cShaprFileCreator.ts +++ b/src/creator/cShaprFileCreator.ts @@ -1,5 +1,3 @@ -import * as vscode from 'vscode'; - import { TemplateType } from '../template/templateType'; import { ExtensionError } from '../util'; import Template from '../template/template'; @@ -17,9 +15,11 @@ export type CreatedFile = { export default class CSharpFileCreator { private _template: TemplateType; + private _templateConfiguration: TemplateConfiguration; - private constructor(templateTypes: TemplateType) { - this._template = templateTypes; + private constructor(templateConfiguration: TemplateConfiguration) { + this._template = templateConfiguration.getTemplateType(); + this._templateConfiguration = templateConfiguration; } public async create(templatesPath: string, pathWithoutExtension: string, newFilename: string): Promise> { @@ -40,8 +40,7 @@ export default class CSharpFileCreator { return Result.error(statuses.readingTemplateError, error.toString()); } - const templateConf = TemplateConfiguration.create(this._template, vscode.workspace.getConfiguration()); - const template = new Template(this._template, templateContent, fileScopedNamespaceConverter, templateConf); + const template = new Template(this._template, templateContent, fileScopedNamespaceConverter, this._templateConfiguration); const namespaceDetector = new NamespaceDetector(pathWithoutExtension); const namespace = await namespaceDetector.getNamespace(); @@ -64,7 +63,7 @@ export default class CSharpFileCreator { return Result.ok({ filePath: destinationFilePath, cursorPositionArray: cursorPositionArray }); } - public static create(template: TemplateType): Result { - return Result.ok(new CSharpFileCreator(template)); + public static create(templateConfiguration: TemplateConfiguration): Result { + return Result.ok(new CSharpFileCreator(templateConfiguration)); } } diff --git a/src/extension.ts b/src/extension.ts index 39375aa..7ec14cc 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -8,6 +8,7 @@ import { log } from './util'; import CSharpFileCreator from './creator/cShaprFileCreator'; import Maybe from './common/maybe'; import { CommandMapping, createExtensionMappings } from './commandMapping'; +import TemplateConfiguration from './template/templateConfiguration'; const EXTENSION_NAME = 'csharpextensions'; @@ -90,8 +91,12 @@ export class Extension { const pathWithoutExtension = `${incomingPath}${path.sep}${newFilename}`; const { templates } = mapping; + const configuration = vscode.workspace.getConfiguration(); + const eol = configuration.get('file.eol', EOL); + const includeNamespaces = configuration.get(`${EXTENSION_NAME}.includeNamespaces`, true); + const createdFilesResult = await Promise.all(templates.map(async template => { - return CSharpFileCreator.create(template) + return CSharpFileCreator.create(TemplateConfiguration.create(template, eol, includeNamespaces)) .AndThen(async creator => await creator.create(templatesPath, pathWithoutExtension, newFilename)); })); @@ -102,6 +107,8 @@ export class Extension { log(error); vscode.window.showErrorMessage(error); + + return; } const files = createdFilesResult.map(result => result.value()).sort((cf1, cf2) => { diff --git a/src/template/templateConfiguration.ts b/src/template/templateConfiguration.ts index bd6022b..fc33ff5 100644 --- a/src/template/templateConfiguration.ts +++ b/src/template/templateConfiguration.ts @@ -1,44 +1,43 @@ import { EOL } from 'os'; -import { WorkspaceConfiguration } from 'vscode'; import { ExtensionError } from '../util'; import { TemplateType } from './templateType'; export default class TemplateConfiguration { + private _templateType: TemplateType; private _includeNamespaces: boolean; private _eolSettings: string; private _requiredUsings: Array; private _optionalUsings: Array; - constructor(includeNamespaces: boolean, eolSettings: string, requiredUsings: Array, optionalUsings: Array) { + private constructor(templateType: TemplateType, includeNamespaces: boolean, eolSettings: string, requiredUsings: Array, optionalUsings: Array) { + this._templateType = templateType; this._includeNamespaces = includeNamespaces; this._eolSettings = eolSettings; this._requiredUsings = requiredUsings; this._optionalUsings = optionalUsings; } + public getTemplateType(): TemplateType { return this._templateType; } public getIncludeNamespaces(): boolean { return this._includeNamespaces; } public getEolSettings(): string { return this._eolSettings; } public getRequiredUsings(): Array { return this._requiredUsings; } public getOptionalUsings(): Array { return this._optionalUsings; } - public static create(type: TemplateType, workspaceConfiguration: WorkspaceConfiguration): TemplateConfiguration { - const eolSettings = TemplateConfiguration.getEolSetting(workspaceConfiguration); - const includeNamespaces = workspaceConfiguration.get('csharpextensions.includeNamespaces', true); + public static create(type: TemplateType, eol: string, includeNamespaces: boolean): TemplateConfiguration { + const eolSettings = TemplateConfiguration.getEolSetting(eol); const requiredUsings = TemplateConfiguration.retrieveRequiredUsings(type); const optionalUsings = TemplateConfiguration.retrieveOptionalUsings(type); - return new TemplateConfiguration(includeNamespaces, eolSettings, requiredUsings, optionalUsings); + return new TemplateConfiguration(type, includeNamespaces, eolSettings, requiredUsings, optionalUsings); } - private static getEolSetting(workspaceConfiguration: WorkspaceConfiguration): string { - const eolSetting = workspaceConfiguration.get('files.eol', EOL); - - switch (eolSetting) { + private static getEolSetting(eol: string): string { + switch (eol) { case '\n': case '\r\n': - return eolSetting; + return eol; case 'auto': default: return EOL; diff --git a/test/suite/unit/creator/cSharpFileCreator.test.ts b/test/suite/unit/creator/cSharpFileCreator.test.ts new file mode 100644 index 0000000..7d5653d --- /dev/null +++ b/test/suite/unit/creator/cSharpFileCreator.test.ts @@ -0,0 +1,103 @@ +import * as assert from 'assert'; +import { beforeEach, afterEach } from 'mocha'; +import { EOL } from 'os'; +import { sep } from 'path'; +import * as sinon from 'sinon'; + +import CSharpFileCreator from '../../../../src/creator/cShaprFileCreator'; +import TemplateConfiguration from '../../../../src/template/templateConfiguration'; +import { TemplateType } from '../../../../src/template/templateType'; +import statuses from '../../../../src/creator/fileCreatorStatus'; +import FileHandler from '../../../../src/io/fileHandler'; + +suite('CSharpFileCreator', () => { + let fakeFileHandler: { + fileExists: () => Promise, + read: () => Promise, + write: () => Promise, + }; + + const templatesPath = 'templates'; + const newFilename = 'File'; + const pathWithoutExtension = `test${sep}suite${sep}unit${sep}creator${sep}${newFilename}`; + const destinationFilePath = `${pathWithoutExtension}.cs`; + + beforeEach(() => { + fakeFileHandler = { + fileExists: sinon.fake.resolves(false), + read: sinon.fake.resolves('template content'), + write: sinon.fake.resolves(undefined), + }; + }); + + afterEach(() => { + sinon.restore(); + sinon.reset(); + }); + + test('Create when a file exists, returns FileExistingError', async () => { + fakeFileHandler.fileExists = sinon.fake.resolves(true); + sinon.replace(FileHandler, 'fileExists', fakeFileHandler.fileExists); + sinon.replace(FileHandler, 'read', fakeFileHandler.read); + sinon.replace(FileHandler, 'write', fakeFileHandler.write); + const useFileScopedNamespace = false; + const error = `File already exists: ${destinationFilePath}`; + + + const configuration = TemplateConfiguration.create(TemplateType.Class, EOL, useFileScopedNamespace); + const fileCreator = CSharpFileCreator.create(configuration).value(); + + const result = await fileCreator.create(templatesPath, pathWithoutExtension, newFilename); + + assert.strictEqual(result.isErr(), true); + assert.strictEqual(result.isOk(), false); + assert.strictEqual(result.status(), statuses.fileExistingError); + assert.strictEqual(result.info(), error); + }); + + test('Create when template cannot be read, returns ReadingTemplateError', async () => { + fakeFileHandler.read= sinon.fake.rejects('Error reading template'); + sinon.replace(FileHandler, 'fileExists', fakeFileHandler.fileExists); + sinon.replace(FileHandler, 'read', fakeFileHandler.read); + sinon.replace(FileHandler, 'write', fakeFileHandler.write); + const configuration = TemplateConfiguration.create(TemplateType.Class, EOL, false); + const fileCreator = CSharpFileCreator.create(configuration).value(); + + const result = await fileCreator.create(templatesPath, pathWithoutExtension, newFilename); + + assert.strictEqual(result.isErr(), true); + assert.strictEqual(result.isOk(), false); + assert.strictEqual(result.status(),statuses.readingTemplateError); + assert.strictEqual(result.info(), 'Error: Error reading template'); + }); + + test('Create when file cannot be written, returns WritingFileError', async () => { + fakeFileHandler.write= sinon.fake.rejects('write error'); + sinon.replace(FileHandler, 'fileExists', fakeFileHandler.fileExists); + sinon.replace(FileHandler, 'read', fakeFileHandler.read); + sinon.replace(FileHandler, 'write', fakeFileHandler.write); + const configuration = TemplateConfiguration.create(TemplateType.Class, EOL, false); + const fileCreator = CSharpFileCreator.create(configuration).value(); + + const result = await fileCreator.create(templatesPath, pathWithoutExtension, newFilename); + + assert.strictEqual(result.isOk(), false); + assert.strictEqual(result.isErr(), true); + assert.strictEqual(result.status(),statuses.writingFileError); + assert.strictEqual(result.info(), 'Error: write error'); + }); + + test('Create file successfully', async () => { + sinon.replace(FileHandler, 'fileExists', fakeFileHandler.fileExists); + sinon.replace(FileHandler, 'read', fakeFileHandler.read); + sinon.replace(FileHandler, 'write', fakeFileHandler.write); + const configuration = TemplateConfiguration.create(TemplateType.Class, EOL, false); + const fileCreator = CSharpFileCreator.create(configuration).value(); + + const result = await fileCreator.create(templatesPath, pathWithoutExtension, newFilename); + + assert(result.isOk()); + assert.strictEqual(result.value().filePath, destinationFilePath); + assert.strictEqual(result.value().cursorPositionArray, null); + }); +}); diff --git a/test/suite/unit/template/template.test.ts b/test/suite/unit/template/template.test.ts index 512c278..a60c98f 100644 --- a/test/suite/unit/template/template.test.ts +++ b/test/suite/unit/template/template.test.ts @@ -1,5 +1,4 @@ import * as assert from 'assert'; -import * as vscode from 'vscode'; import { EOL } from 'os'; import { sortBy, uniq } from 'lodash'; import { sep } from 'path'; @@ -33,7 +32,6 @@ suite('Template', () => { TemplateType.UWPWindowXml, ]; const fileScopedNamespaceConverter = new FileScopedNamespaceConverter(); - const workspaceConfiguration = vscode.workspace.getConfiguration(); allTypes.forEach((type) => { @@ -148,7 +146,7 @@ suite('Template', () => { assert.strictEqual(path, `${testPath}${sep}${expectedTemplateFileName}`); }); test(`Ctor works for type ${TemplateType[type]}`, () => { - const templateConfiguration = TemplateConfiguration.create(type, workspaceConfiguration); + const templateConfiguration = TemplateConfiguration.create(type, EOL, true); const template = new Template(type, '', fileScopedNamespaceConverter, templateConfiguration); assert.strictEqual(template.getName(), Template.RetriveName(type)); assert.strictEqual(template.getContent(), ''); @@ -173,25 +171,25 @@ suite('Template', () => { ]; csharpTypes.forEach((type) => { test(`${TemplateType[type]} build when no content and using namespace false and file scoped namespace false`, () => { - const configuration = new TemplateConfiguration(false, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL,false); const template = new Template(type, '', fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, false); assert.strictEqual(result, ''); }); test(`${TemplateType[type]} build when no content and using namespace true and file scoped namespace false`, () => { - const configuration = new TemplateConfiguration(true, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, true); const template = new Template(type, '', fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, false); assert.strictEqual(result, ''); }); test(`${TemplateType[type]} build when no content and using namespace false and file scoped namespace true`, () => { - const configuration = new TemplateConfiguration(false, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, false); const template = new Template(type, '', fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, true); assert.strictEqual(result, ''); }); test(`${TemplateType[type]} build when namespace gets replaced in non file scope mode`, () => { - const configuration = new TemplateConfiguration(false, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, false); const content = `${EOL}\${namespace}${EOL}{${EOL}}${EOL}`; const template = new Template(type, content, fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, false); @@ -201,7 +199,7 @@ suite('Template', () => { }); test(`${TemplateType[type]} build when namespace gets replaced in non file scope mode but no curly braces`, () => { const content = `${EOL}\${namespace}${EOL}`; - const configuration = new TemplateConfiguration(false, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, false); const template = new Template(type, content, fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, false); const expectedResult = `${EOL}${globalNameSpace}${EOL}`; @@ -210,40 +208,40 @@ suite('Template', () => { }); test(`${TemplateType[type]} build when namespace gets replaced in file scope mode`, () => { const content = `\${namespace}${EOL}{${EOL}}${EOL}`; - const configuration = new TemplateConfiguration(false, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, false); const template = new Template(type, content, fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, true); assert.strictEqual(result, `${globalNameSpace};${EOL}${EOL}${EOL}`); }); test(`${TemplateType[type]} build when EOL gets replaced with \\r\\n`, () => { const content = `${EOL}${EOL}${EOL}`; - const configuration = new TemplateConfiguration(false, '\r\n', new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, '\r\n', false); const template = new Template(type, content, fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, true, ); assert.strictEqual(result, '\r\n\r\n\r\n'); }); test(`${TemplateType[type]} build when EOL gets replaced with \\n`, () => { const content = `${EOL}${EOL}${EOL}`; - const configuration = new TemplateConfiguration(false, '\n', new Array(), new Array()); + const configuration = TemplateConfiguration.create(type,'\n', false); const template = new Template(type, content, fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, true); assert.strictEqual(result, '\n\n\n'); }); test(`${TemplateType[type]} build when class name gets replaced`, () => { - const configuration = new TemplateConfiguration(true, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, true); const template = new Template(type, '${classname}', fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, true); assert.strictEqual(result, 'test'); }); test(`${TemplateType[type]} build when no content and using namespace true and file scoped namespace true`, () => { - const configuration = new TemplateConfiguration(true, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, true); const template = new Template(type, '', fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, true); assert.strictEqual(result, ''); }); test(`${TemplateType[type]} build when namespaces get replaced by required imports`, () => { const content = '${namespaces}'; - const configuration = new TemplateConfiguration(false, EOL, getRequiredImports(type), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, false); const template = new Template(type, content, fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, false); const expectedResult = configuration.getRequiredUsings(); @@ -252,7 +250,7 @@ suite('Template', () => { }); test(`${TemplateType[type]} build when namespaces get replaced by required and optional imports`, () => { const content = '${namespaces}'; - const configuration = new TemplateConfiguration(true, EOL, getRequiredImports(type), getOptionalImports(type)); + const configuration = TemplateConfiguration.create(type, EOL, true); const template = new Template(type, content, fileScopedNamespaceConverter, configuration); const result = template.build('test', globalNameSpace, false); const expectedRequired = configuration.getRequiredUsings(); @@ -261,28 +259,28 @@ suite('Template', () => { assert.strictEqual(result, mergeImports(expectedOptional, expectedRequired)); }); test(`${TemplateType[type]} FindCursorInTemplate when no content and using namespace false and file scoped namespace false`, () => { - const configuration = new TemplateConfiguration(false, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, false); const template = new Template(type, '', fileScopedNamespaceConverter, configuration); const result = template.findCursorInTemplate('test', globalNameSpace, false); assert.strictEqual(result, null); }); test(`${TemplateType[type]} FindCursorInTemplate when no content and using namespace true and file scoped namespace false`, () => { - const configuration = new TemplateConfiguration(true, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, true); const template = new Template(type, '', fileScopedNamespaceConverter, configuration); const result = template.findCursorInTemplate('test', globalNameSpace, false); assert.strictEqual(result, null); }); test(`${TemplateType[type]} FindCursorInTemplate when no content and using namespace false and file scoped namespace true`, () => { - const configuration = new TemplateConfiguration(false, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, false); const template = new Template(type, '', fileScopedNamespaceConverter, configuration); const result = template.findCursorInTemplate('test', globalNameSpace, true); assert.strictEqual(result, null); }); test(`${TemplateType[type]} FindCursorInTemplate when no content and using namespace true and file scoped namespace true`, () => { - const configuration = new TemplateConfiguration(true, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, true); const template = new Template(type, '', fileScopedNamespaceConverter, configuration); const result = template.findCursorInTemplate('test', globalNameSpace, true); @@ -290,7 +288,7 @@ suite('Template', () => { }); test(`${TemplateType[type]} FindCursorInTemplate when cursor defined by one line`, () => { const content = '${cursor}'; - const configuration = new TemplateConfiguration(true, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, true); const template = new Template(type, content, fileScopedNamespaceConverter, configuration); const result = template.findCursorInTemplate('test', globalNameSpace, false); @@ -299,7 +297,7 @@ suite('Template', () => { test(`${TemplateType[type]} FindCursorInTemplate when cursor on second line`, () => { const content = ` \${cursor}`; - const configuration = new TemplateConfiguration(true, EOL, new Array(), new Array()); + const configuration = TemplateConfiguration.create(type, EOL, true); const template = new Template(type, content, fileScopedNamespaceConverter, configuration); const result = template.findCursorInTemplate('test', globalNameSpace, false); @@ -308,110 +306,6 @@ suite('Template', () => { }); }); -function getRequiredImports(type: TemplateType): Array { - let expectedRequired: Array; - switch (type) { - case TemplateType.Class: - case TemplateType.Inteface: - case TemplateType.Enum: - case TemplateType.Struct: - case TemplateType.UWPPageClass: - case TemplateType.UWPUserControllClass: - case TemplateType.UWPWindowClass: - expectedRequired = []; - break; - case TemplateType.Controller: - expectedRequired = [ - 'System.Diagnostics', - 'Microsoft.AspNetCore.Mvc', - 'Microsoft.Extensions.Logging', - ]; - break; - case TemplateType.ApiController: - expectedRequired = ['Microsoft.AspNetCore.Mvc']; - break; - case TemplateType.MsTest: - expectedRequired = ['Microsoft.VisualStudio.TestTools.UnitTesting']; - break; - case TemplateType.NUnit: - expectedRequired = ['NUnit.Framework']; - break; - case TemplateType.XUnit: - expectedRequired = ['Xunit']; - break; - case TemplateType.RazorPageClass: - expectedRequired = [ - 'Microsoft.AspNetCore.Mvc', - 'Microsoft.AspNetCore.Mvc.RazorPages', - 'Microsoft.Extensions.Logging', - ]; - break; - case TemplateType.UWPUserControllXml: - case TemplateType.UWPWindowXml: - case TemplateType.UWPPageXml: - case TemplateType.RazorPageTemplate: - case TemplateType.UWPResource: - return []; - default: - throw new Error(`Not expected type: ${TemplateType[type]}`); - } - - return expectedRequired; -} - -function getOptionalImports(type: TemplateType): Array { - let optionalImports: Array; - switch (type) { - case TemplateType.Class: - case TemplateType.Inteface: - case TemplateType.Enum: - case TemplateType.Struct: - case TemplateType.Controller: - case TemplateType.ApiController: - case TemplateType.MsTest: - case TemplateType.NUnit: - case TemplateType.XUnit: - case TemplateType.RazorPageClass: - optionalImports = [ - 'System', - 'System.Collections.Generic', - 'System.Linq', - 'System.Threading.Tasks', - ]; - break; - case TemplateType.UWPPageClass: - case TemplateType.UWPUserControllClass: - case TemplateType.UWPWindowClass: - optionalImports = [ - 'System', - 'System.Collections.Generic', - 'System.Linq', - 'System.Text', - 'System.Threading.Tasks', - 'System.Windows', - 'System.Windows.Controls', - 'System.Windows.Data', - 'System.Windows.Documents', - 'System.Windows.Input', - 'System.Windows.Media', - 'System.Windows.Media.Imaging', - 'System.Windows.Navigation', - 'System.Windows.Shapes', - ]; - break; - case TemplateType.UWPUserControllXml: - case TemplateType.UWPWindowXml: - case TemplateType.UWPPageXml: - case TemplateType.RazorPageTemplate: - case TemplateType.UWPResource: - return []; - default: - throw new Error(`Not expected type: ${TemplateType[type]}`); - } - - return optionalImports; -} - function mergeImports(arg1: Array, arg2 = new Array()): string { let usings = arg1; usings = usings.concat(arg2); diff --git a/test/suite/unit/template/templateConfiguration.test.ts b/test/suite/unit/template/templateConfiguration.test.ts index 0e1afaa..a358bcf 100644 --- a/test/suite/unit/template/templateConfiguration.test.ts +++ b/test/suite/unit/template/templateConfiguration.test.ts @@ -1,8 +1,8 @@ import * as assert from 'assert'; -import * as vscode from 'vscode'; import TemplateConfiguration from '../../../../src/template/templateConfiguration'; import { TemplateType } from '../../../../src/template/templateType'; +import { EOL } from 'os'; suite('TemplateConfiguration', () => { const allTypes: Array = [ @@ -26,46 +26,34 @@ suite('TemplateConfiguration', () => { TemplateType.UWPWindowXml, ]; allTypes.forEach((type) => { - test(`create for type ${TemplateType[type]} with include namaspaces true and default eol`, async () => { - const workspace = vscode.workspace.getConfiguration(); + test(`create for type ${TemplateType[type]} with include namaspaces true and default eol`, () => { + const configuration = TemplateConfiguration.create(type, EOL, true); - return workspace.update('csharpextensions.includeNamespaces', true, vscode.ConfigurationTarget.Global) - .then(() => { - const configuration = TemplateConfiguration.create(type, workspace); - - // assert.strictEqual(configuration.getIncludeNamespaces(), true); - assert.deepStrictEqual(configuration.getRequiredUsings(), getRequiredImports(type)); - assert.deepStrictEqual(configuration.getOptionalUsings(), getOptionalImports(type)); - }); + assert.strictEqual(configuration.getIncludeNamespaces(), true); + assert.strictEqual(configuration.getEolSettings(), EOL); + assert.deepStrictEqual(configuration.getRequiredUsings(), getRequiredImports(type)); + assert.deepStrictEqual(configuration.getOptionalUsings(), getOptionalImports(type)); }); }); allTypes.forEach((type) => { - test(`create for type ${TemplateType[type]} with include namaspaces false and default eol`, async () => { - const workspace = vscode.workspace.getConfiguration(); - - return workspace.update('csharpextensions.includeNamespaces', false, vscode.ConfigurationTarget.Global) - .then(() => { - const configuration = TemplateConfiguration.create(type, workspace); + test(`create for type ${TemplateType[type]} with include namaspaces false and default eol`, () => { + const configuration = TemplateConfiguration.create(type, EOL, false); - // assert.strictEqual(configuration.getIncludeNamespaces(), false); - assert.deepStrictEqual(configuration.getRequiredUsings(), getRequiredImports(type)); - assert.deepStrictEqual(configuration.getOptionalUsings(), getOptionalImports(type)); - }); + assert.strictEqual(configuration.getIncludeNamespaces(), false); + assert.strictEqual(configuration.getEolSettings(), EOL); + assert.deepStrictEqual(configuration.getRequiredUsings(), getRequiredImports(type)); + assert.deepStrictEqual(configuration.getOptionalUsings(), getOptionalImports(type)); }); }); ['\n', '\r\n', 'someString'].forEach((eolSetting) => { test(`create with eol ${eolSetting}`, async () => { - const workspace = vscode.workspace.getConfiguration(); + const configuration = TemplateConfiguration.create(TemplateType.Class, eolSetting, true); - return workspace.update('files.eol', eolSetting, vscode.ConfigurationTarget.Global) - .then(() => { - const configuration = TemplateConfiguration.create(TemplateType.Class, workspace); + assert.strictEqual(configuration.getEolSettings(), eolSetting === 'someString' ? EOL : eolSetting); + assert.strictEqual(configuration.getIncludeNamespaces(), true); + assert.deepStrictEqual(configuration.getRequiredUsings(), getRequiredImports(TemplateType.Class)); + assert.deepStrictEqual(configuration.getOptionalUsings(), getOptionalImports(TemplateType.Class)); - // assert.strictEqual(configuration.getEolSettings(), eolSetting === 'someString' ? EOL : eolSetting); - // assert.strictEqual(configuration.getIncludeNamespaces(), true); - assert.deepStrictEqual(configuration.getRequiredUsings(), getRequiredImports(TemplateType.Class)); - assert.deepStrictEqual(configuration.getOptionalUsings(), getOptionalImports(TemplateType.Class)); - }); }); });