formatter tests

Author: DonJayamanne

src/test/extension.common.test.ts

@@ -4,26 +4,26 @@
 //
 
 // The module 'assert' provides assertion methods from node
-import * as assert from "assert";
+import * as assert from 'assert';
 
 // You can import and use all API from the 'vscode' module
 // as well as import your extension to test it
-import * as vscode from "vscode";
-import {execPythonFile} from "../client/common/utils";
-import {initialize} from "./initialize";
+import * as vscode from 'vscode';
+import {execPythonFile} from '../client/common/utils';
+import {initialize} from './initialize';
 
 // Defines a Mocha test suite to group tests of similar kind together
-suite("ChildProc", () => {
+suite('ChildProc', () => {
  setup(done => {
  initialize().then(() => done(), done);
  });
- test("Standard Response", done => {
- execPythonFile("python", ["-c", "print(1)"], __dirname, false).then(data => {
- assert.ok(data === "1\n");
+ test('Standard Response', done => {
+ execPythonFile('python', ['-c', 'print(1)'], __dirname, false).then(data => {
+ assert.ok(data === '1\n');
  }).then(done, done);
  });
- test("Error Response", done => {
- execPythonFile("python", ["-c", "print(1"], __dirname, false).then(data => {
+ test('Error Response', done => {
+ execPythonFile('python', ['-c', 'print(1'], __dirname, false).then(data => {
  assert.ok(false);
  }).catch(() => {
  assert.ok(true);

src/test/extension.format.test.ts

@@ -4,113 +4,116 @@
 
 
 // The module 'assert' provides assertion methods from node
-import * as assert from "assert";
+import * as assert from 'assert';
 
 // You can import and use all API from the 'vscode' module
 // as well as import your extension to test it
-import * as vscode from "vscode";
-import {AutoPep8Formatter} from "../client/formatters/autoPep8Formatter";
-import {YapfFormatter} from "../client/formatters/yapfFormatter";
-import * as path from "path";
-import * as settings from "../client/common/configSettings";
-import * as fs from "fs-extra";
-import {initialize} from "./initialize";
+import * as vscode from 'vscode';
+import {AutoPep8Formatter} from '../client/formatters/autoPep8Formatter';
+import {YapfFormatter} from '../client/formatters/yapfFormatter';
+import * as path from 'path';
+import * as settings from '../client/common/configSettings';
+import * as fs from 'fs-extra';
+import {initialize} from './initialize';
+import {execPythonFile} from '../client/common/utils';
 
 let pythonSettings = settings.PythonSettings.getInstance();
-let ch = vscode.window.createOutputChannel("Tests");
-let pythoFilesPath = path.join(__dirname, "..", "..", "src", "test", "pythonFiles", "formatting");
+let ch = vscode.window.createOutputChannel('Tests');
+let pythoFilesPath = path.join(__dirname, '..', '..', 'src', 'test', 'pythonFiles', 'formatting');
+const originalUnformattedFile = path.join(pythoFilesPath, 'fileToFormat.py');
 
-suite("Formatting", () => {
- setup(done => {
- initialize().then(() => done(), done);
- });
+const autoPep8FileToFormat = path.join(__dirname, 'pythonFiles', 'formatting', 'autoPep8FileToFormat.py');
+const autoPep8FileToAutoFormat = path.join(__dirname, 'pythonFiles', 'formatting', 'autoPep8FileToAutoFormat.py');
+const yapfFileToFormat = path.join(__dirname, 'pythonFiles', 'formatting', 'yapfFileToFormat.py');
+const yapfFileToAutoFormat = path.join(__dirname, 'pythonFiles', 'formatting', 'yapfFileToAutoFormat.py');
+
+let formattedYapf = '';
+let formattedAutoPep8 = '';
+
+suiteSetup(done => {
+ initialize().then(() => {
+ [autoPep8FileToFormat, autoPep8FileToAutoFormat, yapfFileToFormat, yapfFileToAutoFormat].forEach(file => {
+ if (fs.existsSync(file)) { fs.unlinkSync(file); }
+ fs.copySync(originalUnformattedFile, file);
+ });
+
+ fs.ensureDirSync(path.dirname(autoPep8FileToFormat));
+ let yapf = execPythonFile('yapf', [originalUnformattedFile], pythoFilesPath, false);
+ let autoPep8 = execPythonFile('autopep8', [originalUnformattedFile], pythoFilesPath, false);
+ return Promise.all<string>([yapf, autoPep8]).then(formattedResults => {
+ formattedYapf = formattedResults[0];
+ formattedAutoPep8 = formattedResults[1];
+ }).then(() => {
+ done();
+ });
+ }, done);
+});
+
+suiteTeardown(() => {
+ if (vscode.window.activeTextEditor) {
+ return vscode.commands.executeCommand('workbench.action.closeActiveEditor');
+ }
+});
+
+suite('Formatting', () => {
  teardown(() => {
  if (vscode.window.activeTextEditor) {
- return vscode.commands.executeCommand("workbench.action.closeActiveEditor");
+ return vscode.commands.executeCommand('workbench.action.closeActiveEditor');
  }
- return Promise.resolve();
  });
- test("AutoPep8", done => {
- let fileToFormat = path.join(pythoFilesPath, "beforeAutoPep8.py");
+ function testFormatting(formatter: AutoPep8Formatter | YapfFormatter, formattedContents: string, fileToFormat: string): PromiseLike<void> {
  let textEditor: vscode.TextEditor;
  let textDocument: vscode.TextDocument;
- vscode.workspace.openTextDocument(fileToFormat).then(document => {
+ return vscode.workspace.openTextDocument(fileToFormat).then(document => {
  textDocument = document;
  return vscode.window.showTextDocument(textDocument);
  }).then(editor => {
  textEditor = editor;
- let formatter = new AutoPep8Formatter(ch, pythonSettings, pythoFilesPath);
  return formatter.formatDocument(textDocument, null, null);
  }).then(edits => {
  return textEditor.edit(editBuilder => {
  edits.forEach(edit => editBuilder.replace(edit.range, edit.newText));
  });
  }).then(edited => {
- let formattedFile = path.join(pythoFilesPath, "afterAutoPep8.py");
- let formattedContents = fs.readFile(formattedFile, "utf-8", (error, data) => {
- if (error) {
- return assert.fail(error, "", "Failed to read formatted file");
- }
- assert.equal(textEditor.document.getText(), data, "Formatted text is not the same");
- });
- }).then(done, done);
+ assert.equal(textEditor.document.getText(), formattedContents, 'Formatted text is not the same');
+ });
+ }
+ test('AutoPep8', done => {
+ testFormatting(new AutoPep8Formatter(ch, pythonSettings, pythoFilesPath), formattedAutoPep8, autoPep8FileToFormat).then(done, done);
  });
 
- test("Yapf", done => {
- let fileToFormat = path.join(pythoFilesPath, "beforeYapf.py");
- let textEditor: vscode.TextEditor;
- let textDocument: vscode.TextDocument;
- vscode.workspace.openTextDocument(fileToFormat).then(document => {
- textDocument = document;
- return vscode.window.showTextDocument(textDocument);
- }).then(editor => {
- textEditor = editor;
- let formatter = new YapfFormatter(ch, pythonSettings, pythoFilesPath);
- return formatter.formatDocument(textDocument, null, null);
- }).then(edits => {
- return textEditor.edit(editBuilder => {
- edits.forEach(edit => editBuilder.replace(edit.range, edit.newText));
- });
- }).then(edited => {
- let formattedFile = path.join(pythoFilesPath, "afterYapf.py");
- let formattedContents = fs.readFile(formattedFile, "utf-8", (error, data) => {
- if (error) {
- return assert.fail(error, "", "Failed to read formatted file");
- }
- assert.equal(textEditor.document.getText(), data, "Formatted text is not the same");
- });
- }).then(done, done);
+ test('Yapf', done => {
+ testFormatting(new YapfFormatter(ch, pythonSettings, pythoFilesPath), formattedYapf, yapfFileToFormat).then(done, done);
  });
 
- test("Yapf autoformat on save", done => {
- let formattedFile = path.join(pythoFilesPath, "afterYapfFormatOnSave.py");
- let fileToCopyFrom = path.join(pythoFilesPath, "beforeYapfFormatOnSaveOriginal.py");
- let formattedFileContents = fs.readFileSync(formattedFile, "utf-8");
-
- let fileToFormat = path.join(pythoFilesPath, "beforeYapf.py");
+ function testAutoFormatting(formatter: string, formattedContents: string, fileToFormat: string): PromiseLike<void> {
  let textDocument: vscode.TextDocument;
-
- if (fs.existsSync(fileToFormat)) { fs.unlinkSync(fileToFormat); }
- fs.copySync(fileToCopyFrom, fileToFormat);
- const FORMAT_ON_SAVE = pythonSettings.formatting.formatOnSave;
  pythonSettings.formatting.formatOnSave = true;
- pythonSettings.formatting.provider = "yapf";
-
- vscode.workspace.openTextDocument(fileToFormat).then(document => {
+ pythonSettings.formatting.provider = formatter;
+ return vscode.workspace.openTextDocument(fileToFormat).then(document => {
  textDocument = document;
  return vscode.window.showTextDocument(textDocument);
  }).then(editor => {
  return editor.edit(editBuilder => {
- editBuilder.insert(new vscode.Position(0, 0), "#\n");
+ editBuilder.insert(new vscode.Position(0, 0), '#\n');
  });
+ }).then(edited => {
+ return textDocument.save();
  }).then(saved => {
  return new Promise<any>((resolve, reject) => {
  setTimeout(() => {
  resolve();
  }, 1000);
  });
  }).then(() => {
- assert.equal(textDocument.getText(), formattedFileContents, "Formatted contents are not the same");
- }).then(done, done);
+ assert.equal(textDocument.getText(), formattedContents, 'Formatted contents are not the same');
+ });
+ }
+ test('AutoPep8 autoformat on save', done => {
+ testAutoFormatting('autopep8', '#\n' + formattedAutoPep8, autoPep8FileToAutoFormat).then(done, done);
+ });
+
+ test('Yapf autoformat on save', done => {
+ testAutoFormatting('yapf', '#\n' + formattedYapf, yapfFileToAutoFormat).then(done, done);
  });
 });

src/test/index.ts

@@ -10,14 +10,14 @@
 // to report the results back to the caller. When the tests are finished, return
 // a possible error to the callback or null if none.
 
-let testRunner = require("vscode/lib/testrunner");
+let testRunner = require('vscode/lib/testrunner');
 
 // You can directly control Mocha options by uncommenting the following lines
 // See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
 testRunner.configure({
- ui: "tdd", // the TDD UI is being used in extension.test.ts (suite, test, etc.)
+ ui: 'tdd', // the TDD UI is being used in extension.test.ts (suite, test, etc.)
  useColors: true, // colored output from test results
- timeout: 5000
+ timeout: 10000
 });
 
 module.exports = testRunner;