test fixes

Author: DonJayamanne

src/test/autocomplete/base.test.ts

@@ -3,7 +3,7 @@
 
 
 // Place this right on top
-import { initialize, PYTHON_PATH, closeActiveWindows } from '../initialize';
+import { initialize, PYTHON_PATH, closeActiveWindows, setPythonExecutable } from '../initialize';
 // The module 'assert' provides assertion methods from node
 import * as assert from 'assert';
 import { EOL } from 'os';
@@ -12,8 +12,11 @@ import { EOL } from 'os';
 import * as vscode from 'vscode';
 import * as path from 'path';
 import * as settings from '../../client/common/configSettings';
+import { execPythonFile } from '../../client/common/utils';
+import { createDeferred } from '../../client/common/helpers';
 
 let pythonSettings = settings.PythonSettings.getInstance();
+let disposable: vscode.Disposable;
 let autoCompPath = path.join(__dirname, '..', '..', '..', 'src', 'test', 'pythonFiles', 'autocomp');
 const fileOne = path.join(autoCompPath, 'one.py');
 const fileImport = path.join(autoCompPath, 'imp.py');
@@ -24,11 +27,13 @@ const fileEncoding = path.join(autoCompPath, 'four.py');
 const fileEncodingUsed = path.join(autoCompPath, 'five.py');
 
 suite('Autocomplete', () => {
-    suiteSetup(done => {
-        initialize().then(() => {
-            pythonSettings.pythonPath = PYTHON_PATH;
-            done();
-        }, done);
+    const isPython3Deferred = createDeferred<boolean>();
+    const isPython3 = isPython3Deferred.promise;
+    suiteSetup(async () => {
+        disposable = setPythonExecutable(pythonSettings);
+        await initialize();
+        let version = await execPythonFile(pythonSettings.pythonPath, ['--version'], __dirname, true);
+        isPython3Deferred.resolve(version.indexOf('3.') >= 0);
     });
 
     suiteTeardown(done => {
@@ -78,6 +83,9 @@ suite('Autocomplete', () => {
 
     // https://github.com/DonJayamanne/pythonVSCode/issues/265
     test('For "lambda"', async () => {
+        if (!await isPython3) {
+            return;
+        }
         const textDocument = await vscode.workspace.openTextDocument(fileLambda);
         await vscode.window.showTextDocument(textDocument);
         const position = new vscode.Position(1, 19);

src/test/definitions/code.test.ts

@@ -110,8 +110,11 @@ suite('Code Definition', () => {
         const position = new vscode.Position(13, 2);
         const def = await vscode.commands.executeCommand<vscode.Location[]>('vscode.executeDefinitionProvider', textDocument.uri, position);
         assert.equal(def.length, 1, 'Definition length is incorrect');
-        assert.equal(`${def[0].range.start.line},${def[0].range.start.character}`, '19,0', 'Start position is incorrect');
-        assert.equal(`${def[0].range.end.line},${def[0].range.end.character}`, '26,42', 'End position is incorrect');
+        if (!def[0].uri.fsPath.endsWith('operations.py')) {
+            assert.fail(def[0].uri.fsPath, 'operations.py', 'Source of sudo is incorrect', 'file source');
+        }
+        assert.equal(`${def[0].range.start.line},${def[0].range.start.character}`, '1094,0', 'Start position is incorrect (3rd part operations.py could have changed)');
+        assert.equal(`${def[0].range.end.line},${def[0].range.end.character}`, '1148,4', 'End position is incorrect (3rd part operations.py could have changed)');
     });
 
     test('Go to function decorator', async () => {

src/test/definitions/hover.test.ts

@@ -271,22 +271,15 @@ suite('Hover Definition', () => {
         }).then(def => {
             assert.equal(def.length, 1, 'Definition length is incorrect');
             assert.equal(def[0].contents.length, 1, 'Only expected one result');
-            const expectedContent = '```python' + EOL +
-                'Random' + EOL +
-                '```' + EOL +
-                'Random(self, x=None)' + EOL +
-                EOL +
-                'Random number generator base class used by bound module functions.' + EOL +
-                EOL +
-                "Used to instantiate instances of Random to get generators that don't" + EOL +
-                'share state.' + EOL +
-                EOL +
-                'Class Random can also be subclassed if you want to use a different basic' + EOL +
-                'generator of your own devising: in that case, override the following' + EOL + EOL +
-                '`methods`  random(), seed(), getstate(), and setstate().' + EOL + EOL +
-                'Optionally, implement a getrandbits() method so that randrange()' + EOL +
-                'can cover arbitrarily large ranges.';
-            assert.equal(def[0].contents[0], expectedContent, 'Invalid content items');
+            if (def[0].contents[0].toString().indexOf("```python") === -1) {
+                assert.fail(def[0].contents[0].toString(), "", "First line is incorrect", "compare");
+            }
+            if (def[0].contents[0].toString().indexOf("Random number generator base class used by bound module functions.") === -1) {
+                assert.fail(def[0].contents[0].toString(), "", "'Random number generator' message missing", "compare");
+            }
+            if (def[0].contents[0].toString().indexOf("Class Random can also be subclassed if you want to use a different basic") === -1) {
+                assert.fail(def[0].contents[0].toString(), "", "'Class Random message' missing", "compare");
+            }
         }).then(done, done);
     });
 
@@ -297,11 +290,12 @@ suite('Hover Definition', () => {
         const def = await vscode.commands.executeCommand<vscode.Hover[]>('vscode.executeHoverProvider', textDocument.uri, position);
         assert.equal(def.length, 1, 'Definition length is incorrect');
         assert.equal(def[0].contents.length, 1, 'Only expected one result');
-        const expectedContents = "```python" + EOL +
-            "def capitalize()" + EOL +
-            "```" + EOL + "S.capitalize() -> str" + EOL + EOL +
-            "Return a capitalized version of S, i.e. make the first character" + EOL +
-            "have upper case and the rest lower case.";
-        assert.equal(def[0].contents[0], expectedContents, 'Invalid content items');
+        if (def[0].contents[0].toString().indexOf("def capitalize") === -1) {
+            assert.fail(def[0].contents[0].toString(), "", "'def capitalize' is missing", "compare");
+        }
+        if (def[0].contents[0].toString().indexOf("Return a capitalized version of S") === -1 &&
+            def[0].contents[0].toString().indexOf("Return a copy of the string S with only its first character") === -1) {
+            assert.fail(def[0].contents[0].toString(), "", "'Return a capitalized version of S/Return a copy of the string S with only its first character' message missing", "compare");
+        }
     });
 });