(GH-1336) Add integration tests for the Folding Provider

Previously there were no tests to verify the folding provider.  Due to the
provider depending on 3rd party libraries (vscode-textmate and PowerShell
grammar file) these tests will provide a degree of detection if breaking changes
occur.

Author: glennsarti

test/features/folding.test.ts

@@ -0,0 +1,57 @@
+import * as assert from "assert";
+import * as path from "path";
+import * as vscode from "vscode";
+import { DocumentSelector } from "vscode-languageclient";
+import * as folding from "../../src/features/Folding";
+import { MockLogger } from "../test_utils";
+
+const fixturePath = path.join(__dirname, "..", "..", "..", "test", "fixtures");
+
+function assertFoldingRegions(result, expected): void {
+    assert.equal(result.length, expected.length);
+
+    for (let i = 0; i < expected.length; i++) {
+        const failMessage = `expected ${JSON.stringify(expected[i])}, actual ${JSON.stringify(result[i])}`;
+        assert.equal(result[i].start, expected[i].start, failMessage);
+        assert.equal(result[i].end, expected[i].end, failMessage);
+        assert.equal(result[i].kind, expected[i].kind, failMessage);
+    }
+}
+
+suite("Features", () => {
+
+    suite("Folding Provider", () => {
+        const logger: MockLogger = new MockLogger();
+        const mockSelector: DocumentSelector = [
+            { language: "powershell", scheme: "file" },
+        ];
+        const psGrammar = (new folding.FoldingFeature(logger, mockSelector)).grammar(logger);
+        const provider = (new folding.FoldingProvider(psGrammar));
+
+        test("Can detect the PowerShell Grammar", () => {
+            assert.notEqual(psGrammar, null);
+        });
+
+        test("Can detect all of the foldable regions in a document", async () => {
+            // Integration test against the test fixture 'folding.ps1' that contains
+            // all of the different types of folding available
+            const uri = vscode.Uri.file(path.join(fixturePath, "folding.ps1"));
+            const document = await vscode.workspace.openTextDocument(uri);
+            const result = await provider.provideFoldingRanges(document, null, null);
+
+            const expected = [
+                { start: 1,  end: 6,  kind: 1 },
+                { start: 7,  end: 46, kind: 3 },
+                { start: 8,  end: 13, kind: 1 },
+                { start: 14, end: 17, kind: 3 },
+                { start: 21, end: 23, kind: 1 },
+                { start: 25, end: 35, kind: 3 },
+                { start: 27, end: 31, kind: 3 },
+                { start: 37, end: 39, kind: 3 },
+                { start: 42, end: 45, kind: 3 },
+            ];
+
+            assertFoldingRegions(result, expected);
+        });
+    });
+});

test/fixtures/folding.ps1

@@ -0,0 +1,47 @@
+function short-func {};
+<#
+.SYNOPSIS
+  Displays a list of WMI Classes based upon a search criteria
+.EXAMPLE
+ Get-WmiClasses -class disk -ns rootcimv2"
+#>
+function New-VSCodeCannotFold {
+<#
+.SYNOPSIS
+  Displays a list of WMI Classes based upon a search criteria
+.EXAMPLE
+ Get-WmiClasses -class disk -ns rootcimv2"
+#>
+  $I = @'
+cannot fold
+
+'@
+
+  # this won't be folded
+
+  # This should be foldable
+  # This should be foldable
+  # This should be foldable
+
+  #region This fools the indentation folding.
+  Write-Host "Hello"
+    # region
+    Write-Host "Hello"
+    # comment1
+    Write-Host "Hello"
+    #endregion
+    Write-Host "Hello"
+    # comment2
+    Write-Host "Hello"
+    # endregion
+
+  $c = {
+    Write-Host "Hello"
+  }
+
+  # Array fools indentation folding
+  $d = @(
+  'element1',
+  'elemet2'
+  )
+}

test/test_utils.ts

@@ -0,0 +1,29 @@
+import { Logger, LogLevel } from "../src/logging";
+
+export class MockLogger extends Logger {
+    // Note - This is not a true mock as the constructor is inherited and causes errors due to trying load
+    // the "PowerShell Extension Logs" multiple times.  Ideally logging should be via an interface and then
+    // we can mock correctly.
+
+    public dispose() { return undefined; }
+
+    public getLogFilePath(baseName: string): string { return "mock"; }
+
+    public writeAtLevel(logLevel: LogLevel, message: string, ...additionalMessages: string[]) { return undefined; }
+
+    public write(message: string, ...additionalMessages: string[]) { return undefined; }
+
+    public writeDiagnostic(message: string, ...additionalMessages: string[]) { return undefined; }
+
+    public writeVerbose(message: string, ...additionalMessages: string[]) { return undefined; }
+
+    public writeWarning(message: string, ...additionalMessages: string[]) { return undefined; }
+
+    public writeAndShowWarning(message: string, ...additionalMessages: string[]) { return undefined; }
+
+    public writeError(message: string, ...additionalMessages: string[]) { return undefined; }
+
+    public writeAndShowError(message: string, ...additionalMessages: string[]) { return undefined; }
+
+    public startNewLog(minimumLogLevel: string = "Normal") { return undefined; }
+}