Use showOmnisharpLogOnError setting in all channels

Addresses dotnet#4608, dotnet#3708

src/main.ts

@@ -69,19 +69,19 @@ export async function activate(context: vscode.ExtensionContext): Promise<CSharp
     let optionProvider = new OptionProvider(optionStream);
 
     let dotnetChannel = vscode.window.createOutputChannel('.NET');
-    let dotnetChannelObserver = new DotNetChannelObserver(dotnetChannel);
+    let dotnetChannelObserver = new DotNetChannelObserver(dotnetChannel, vscode);
     let dotnetLoggerObserver = new DotnetLoggerObserver(dotnetChannel);
     eventStream.subscribe(dotnetChannelObserver.post);
     eventStream.subscribe(dotnetLoggerObserver.post);
 
     let dotnetTestChannel = vscode.window.createOutputChannel(".NET Test Log");
-    let dotnetTestChannelObserver = new DotNetTestChannelObserver(dotnetTestChannel);
+    let dotnetTestChannelObserver = new DotNetTestChannelObserver(dotnetTestChannel, vscode);
     let dotnetTestLoggerObserver = new DotNetTestLoggerObserver(dotnetTestChannel);
     eventStream.subscribe(dotnetTestChannelObserver.post);
     eventStream.subscribe(dotnetTestLoggerObserver.post);
 
     let csharpChannel = vscode.window.createOutputChannel('C#');
-    let csharpchannelObserver = new CsharpChannelObserver(csharpChannel);
+    let csharpchannelObserver = new CsharpChannelObserver(csharpChannel,vscode);
     let csharpLogObserver = new CsharpLoggerObserver(csharpChannel);
     eventStream.subscribe(csharpchannelObserver.post);
     eventStream.subscribe(csharpLogObserver.post);

src/observers/CsharpChannelObserver.ts

@@ -6,8 +6,13 @@
 import { BaseChannelObserver } from "./BaseChannelObserver";
 import { EventType } from "../omnisharp/EventType";
 import { BaseEvent } from "../omnisharp/loggingEvents";
+import { OutputChannel, vscode } from "../vscodeAdapter";
 
 export class CsharpChannelObserver extends BaseChannelObserver {
+    constructor(channel: OutputChannel, private vscode: vscode) {
+        super(channel);
+    }
+
     public post = (event: BaseEvent) => {
         switch (event.type) {
             case EventType.PackageInstallStart:
@@ -16,7 +21,10 @@ export class CsharpChannelObserver extends BaseChannelObserver {
             case EventType.DebuggerNotInstalledFailure:
             case EventType.DebuggerPrerequisiteFailure:
             case EventType.ProjectJsonDeprecatedWarning:
-                this.showChannel(true);
+                let csharpConfig = this.vscode.workspace.getConfiguration('csharp');
+                if (csharpConfig.get<boolean>('showOmnisharpLogOnError')) {
+                    this.showChannel(true);
+                }
                 break;
         }
     }

src/observers/DotnetChannelObserver.ts

@@ -6,13 +6,21 @@
 import { BaseChannelObserver } from "./BaseChannelObserver";
 import { BaseEvent } from "../omnisharp/loggingEvents";
 import { EventType } from "../omnisharp/EventType";
+import { OutputChannel, vscode } from "../vscodeAdapter";
 
 export class DotNetChannelObserver extends BaseChannelObserver {
+    constructor(channel: OutputChannel, private vscode: vscode) {
+        super(channel);
+    }
+
     public post = (event: BaseEvent) => {
         switch (event.type) {
             case EventType.CommandDotNetRestoreStart:
                 this.clearChannel();
-                this.showChannel(true);
+                let csharpConfig = this.vscode.workspace.getConfiguration('csharp');
+                if (csharpConfig.get<boolean>('showOmnisharpLogOnError')) {
+                    this.showChannel(true);
+                }
                 break;
         }
     }

src/observers/DotnetTestChannelObserver.ts

@@ -6,8 +6,13 @@
 import { BaseChannelObserver } from "./BaseChannelObserver";
 import { BaseEvent } from "../omnisharp/loggingEvents";
 import { EventType } from "../omnisharp/EventType";
+import { OutputChannel , vscode } from "../vscodeAdapter";
 
 export default class DotnetTestChannelObserver extends BaseChannelObserver {
+    constructor(channel: OutputChannel, private vscode: vscode) {
+        super(channel);
+    }
+
     public post = (event: BaseEvent) => {
         switch (event.type) {
             case EventType.DotNetTestRunStart:
@@ -17,7 +22,10 @@ export default class DotnetTestChannelObserver extends BaseChannelObserver {
             case EventType.DotNetTestsInClassDebugStart:
             case EventType.DotNetTestRunInContextStart:
             case EventType.DotNetTestDebugInContextStart:
-                this.showChannel(true);
+                let csharpConfig = this.vscode.workspace.getConfiguration('csharp');
+                if (csharpConfig.get<boolean>('showOmnisharpLogOnError')) {
+                    this.showChannel(true);
+                }
                 break;
         }
     }

src/observers/OmnisharpChannelObserver.ts

@@ -17,7 +17,10 @@ export class OmnisharpChannelObserver extends BaseChannelObserver {
         switch (event.type) {
             case EventType.ShowOmniSharpChannel:
             case EventType.OmnisharpFailure:
-                this.showChannel(true);
+                let csharpConfig = this.vscode.workspace.getConfiguration('csharp');
+                if (csharpConfig.get<boolean>('showOmnisharpLogOnError')) {
+                    this.showChannel(true);
+                }
                 break;
             case EventType.OmnisharpServerOnStdErr:
                 this.handleOmnisharpServerOnStdErr(<OmnisharpServerOnStdErr>event);

test/unitTests/logging/CsharpChannelObserver.test.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { should, expect } from 'chai';
-import { getNullChannel } from '../testAssets/Fakes';
+import { getNullChannel, getVSCodeWithConfig, updateConfig } from '../testAssets/Fakes';
 import { CsharpChannelObserver } from '../../../src/observers/CsharpChannelObserver';
 import { InstallationFailure, DebuggerNotInstalledFailure, DebuggerPrerequisiteFailure, ProjectJsonDeprecatedWarning, BaseEvent, PackageInstallStart, IntegrityCheckFailure } from '../../../src/omnisharp/loggingEvents';
 
@@ -21,14 +21,18 @@ suite("CsharpChannelObserver", () => {
         test(`${event.constructor.name}: Channel is shown and preserve focus is set to true`, () => {
             let hasShown = false;
             let preserveFocus = false;
-            let observer = new CsharpChannelObserver({
-                ...getNullChannel(),
-                show: (preserve) => {
-                    hasShown = true;
-                    preserveFocus = preserve;
-                }
-            });
-
+            let vscode = getVSCodeWithConfig();
+            let observer = new CsharpChannelObserver(
+                {
+                    ...getNullChannel(),
+                    show: (preserve) => {
+                        hasShown = true;
+                        preserveFocus = preserve;
+                    }
+                },
+                vscode
+            );
+            updateConfig(vscode, "csharp", "showOmnisharpLogOnError", true);
             observer.post(event);
             expect(hasShown).to.be.true;
             expect(preserveFocus).to.be.true;

test/unitTests/logging/DotnetChannelObserver.test.ts

@@ -5,19 +5,23 @@
 
 import { should, expect } from 'chai';
 import { DotNetChannelObserver } from "../../../src/observers/DotnetChannelObserver";
-import { getNullChannel } from '../testAssets/Fakes';
+import { getNullChannel, getVSCodeWithConfig, updateConfig } from '../testAssets/Fakes';
 import { CommandDotNetRestoreStart } from '../../../src/omnisharp/loggingEvents';
 
 suite("DotnetChannelObserver", () => {
     suiteSetup(() => should());
     let hasShown: boolean;
     let hasCleared: boolean;
-
-    let observer = new DotNetChannelObserver({
-        ...getNullChannel(),
-        clear: () => { hasCleared = true; },
-        show: () => { hasShown = true; }
-    });
+    let vscode = getVSCodeWithConfig();
+    let observer = new DotNetChannelObserver(
+        {
+            ...getNullChannel(),
+            clear: () => { hasCleared = true; },
+            show: () => { hasShown = true; }
+        },
+        vscode
+    );
+    updateConfig(vscode, "csharp", "showOmnisharpLogOnError", true);
 
     setup(() => {
         hasShown = false;

test/unitTests/logging/DotnetTestChannelObserver.test.ts

@@ -4,21 +4,25 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { expect } from 'chai';
-import { getNullChannel } from '../testAssets/Fakes';
+import { getNullChannel, getVSCodeWithConfig, updateConfig } from '../testAssets/Fakes';
 import { BaseEvent, DotNetTestsInClassDebugStart, DotNetTestRunStart, DotNetTestRunFailure, DotNetTestsInClassRunStart, DotNetTestDebugStart } from '../../../src/omnisharp/loggingEvents';
 import DotnetTestChannelObserver from '../../../src/observers/DotnetTestChannelObserver';
 
 suite("DotnetTestChannelObserver", () => {
     let hasShown: boolean;
     let preserveFocus: boolean;
-
-    let observer = new DotnetTestChannelObserver({
-        ...getNullChannel(),
-        show: (preserve) => {
-            hasShown = true;
-            preserveFocus = preserve;
-        }
-    });
+    let vscode = getVSCodeWithConfig();
+    let observer = new DotnetTestChannelObserver(
+        {
+            ...getNullChannel(),
+            show: (preserve) => {
+                hasShown = true;
+                preserveFocus = preserve;
+            }
+        },
+        vscode
+    );
+    updateConfig(vscode, "csharp", "showOmnisharpLogOnError", true);
 
     setup(() => {
         hasShown = false;