[DYN-2680] Write logs to std out instead of creating new files for each test. (#10651)

reddyashish · web-flow · commit 888faceef643 · 2020-05-15T10:18:20.000-04:00
* Write logs to std out instead of creating new files for each test.

This is to avoid storing these large number of logs on the VM which is affecting its performance over time.

* Fix for API break change.

* Fixing the failing tests.

These tests verify that the logs are written to dynamo console and to a file. When we changed the behaviour to write the logs to std out in test mode, there were failing. Fixed them accordingly.

* Avoid the stream writer object, no longer needed.
diff --git a/src/DynamoCore/Logging/DynamoLogger.cs b/src/DynamoCore/Logging/DynamoLogger.cs
@@ -5,7 +5,6 @@
 using Dynamo.Configuration;
 using Dynamo.Core;
 using Dynamo.Exceptions;
-using Dynamo.Interfaces;
 
 namespace Dynamo.Logging
 {
@@ -75,6 +74,7 @@ public class DynamoLogger: NotificationObject, ILogger, IDisposable
         private string _warning;
         private WarningLevel _warningLevel;
         private bool _isDisposed;
+        private bool testMode;
 
         private TextWriter FileWriter { get; set; }
         private StringBuilder ConsoleWriter { get; set; }
@@ -157,7 +157,20 @@ public IEnumerable<NotificationMessage> StartupNotifications
         /// </summary>
         /// <param name="debugSettings">Debug settings</param>
         /// <param name="logDirectory">Directory path where log file will be written</param>
-        public DynamoLogger(DebugSettings debugSettings, string logDirectory)
+        [Obsolete("This will be removed in 3.0, please use DynamoLogger(debugSettings, logDirectory, isTestMode) instead.")]
+        public DynamoLogger(DebugSettings debugSettings, string logDirectory) : this(debugSettings, logDirectory, false)
+        {
+            
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="DynamoLogger"/> class
+        /// with specified debug settings and directory where to write logs
+        /// </summary>
+        /// <param name="debugSettings">Debug settings</param>
+        /// <param name="logDirectory">Directory path where log file will be written</param>
+        /// <param name="isTestMode">Test mode is true or false.</param>
+        public DynamoLogger(DebugSettings debugSettings, string logDirectory, Boolean isTestMode)
         {
             lock (guardMutex)
             {
@@ -169,7 +182,12 @@ public DynamoLogger(DebugSettings debugSettings, string logDirectory)
 
                 notifications = new List<NotificationMessage>();
 
-                StartLogging(logDirectory);
+                testMode = isTestMode;
+
+                if (!testMode)
+                {
+                    StartLoggingToConsoleAndFile(logDirectory);
+                }
             }
         }
 
@@ -197,6 +215,13 @@ private void Log(string message, LogLevel level, bool reportModification)
                 if (debugSettings.VerboseLogging)
                     Analytics.LogPiiInfo("LogMessage-" + level.ToString(), message);
 
+                // In test mode, write the logs only to std out. 
+                if (testMode)
+                {
+                    Console.WriteLine(string.Format("{0} : {1}", DateTime.UtcNow.ToString("u"), message));
+                    return;
+                }
+
                 switch (level)
                 {
                         //write to the console
@@ -377,7 +402,7 @@ internal void ClearLog()
         /// <summary>
         /// Begin logging.
         /// </summary>
-        private void StartLogging(string logDirectory)
+        private void StartLoggingToConsoleAndFile(string logDirectory)
         {
             lock (this.guardMutex)
             {
diff --git a/src/DynamoCore/Models/DynamoModel.cs b/src/DynamoCore/Models/DynamoModel.cs
@@ -570,7 +570,7 @@ protected DynamoModel(IStartConfiguration config)
             IsHeadless = config.IsHeadless;
 
             DebugSettings = new DebugSettings();
-            Logger = new DynamoLogger(DebugSettings, pathManager.LogDirectory);
+            Logger = new DynamoLogger(DebugSettings, pathManager.LogDirectory, IsTestMode);
 
             foreach (var exception in exceptions)
             {
diff --git a/test/DynamoCoreTests/CoreTests.cs b/test/DynamoCoreTests/CoreTests.cs
@@ -16,6 +16,7 @@
 using Dynamo.Graph.Workspaces;
 using Dynamo.Models;
 using Dynamo.Selection;
+using Dynamo.Tests.Loggings;
 using NUnit.Framework;
 using DynCmd = Dynamo.Models.DynamoModel;
 
@@ -235,10 +236,17 @@ public void CanAddToSelectionCommand()
         [Category("UnitTests")]
         public void CanClearLog()
         {
-            Assert.AreNotEqual(0, CurrentDynamoModel.Logger.LogText.Length);
+            // Get the dynamo logger in non-test mode, as we write the logs
+            // to dynamo console and to a file only in non-test mode. 
 
-            CurrentDynamoModel.Logger.ClearLog();
-            Assert.AreEqual(0, CurrentDynamoModel.Logger.LogText.Length);
+            DynamoLoggerTest dynamoLoggerTest = new DynamoLoggerTest();
+            var logger = dynamoLoggerTest.GetDynamoLoggerWithTestModeFalse();
+
+            Assert.AreNotEqual(0, logger.LogText.Length);
+
+            logger.ClearLog();
+
+            Assert.AreEqual(0, logger.LogText.Length);
         }
 
         // Clearworkspace
diff --git a/test/DynamoCoreTests/Logging/DynamoLoggerTest.cs b/test/DynamoCoreTests/Logging/DynamoLoggerTest.cs
@@ -1,13 +1,9 @@
-﻿using Dynamo.Logging;
-using Dynamo.Updates;
-using Moq;
-using NUnit.Framework;
-using DynUpdateManager = Dynamo.Updates.UpdateManager;
+﻿using System;
+using System.Collections.Generic;
 using Dynamo.Configuration;
 using Dynamo.Core;
-using System.Collections.Generic;
-using System;
-using Dynamo.Interfaces;
+using Dynamo.Logging;
+using NUnit.Framework;
 
 namespace Dynamo.Tests.Loggings
 {
@@ -17,6 +13,28 @@ class DynamoLoggerTest : DynamoModelTestBase
         private const string DOWNLOAD_SOURCE_PATH_S = "https://downloadsourcepath/";
         private const string SIGNATURE_SOURCE_PATH_S = "https://SignatureSourcePath/";
         private PathManager pathManager;
+        internal DynamoLogger logger;
+
+        // Returns the dynamo logger object in non-test mode. 
+        internal DynamoLogger GetDynamoLoggerWithTestModeFalse()
+        {
+            pathManager = new PathManager(new PathManagerParams{ });
+
+            // Ensure we have all directories in place.
+            var exceptions = new List<Exception>();
+            pathManager.EnsureDirectoryExistence(exceptions);
+
+            //By setting the VerboseLogging we will enable a piece of code inside the method::
+            //private void Log(string message, LogLevel level, bool reportModification)
+            var debugSettings = new DebugSettings
+            {
+                VerboseLogging = true
+            };
+
+            var logger = new DynamoLogger(debugSettings, pathManager.LogDirectory, false);
+
+            return logger;
+        }
 
         /// <summary>
         /// This test method will check the LogEventArgs.LogEventArgs
@@ -45,27 +63,9 @@ public void test_dynamologger_LogEventArgs()
         [Category("UnitTests")]
         public void test_dynamologger_logger()
         {
-            //Arrange
-            //This has been done in the base class but we need to do it again because the pathManager is private
-            var config = CreateStartConfiguration(dynamoSettings);
-            pathManager = new PathManager(new PathManagerParams
-            {
-                CorePath = config.DynamoCorePath,
-                HostPath = config.DynamoHostPath,
-                PathResolver = config.PathResolver
-            });
-
-            // Ensure we have all directories in place.
-            var exceptions = new List<Exception>();
-            pathManager.EnsureDirectoryExistence(exceptions);
-
-            //By setting the VerboseLogging we will enable a piece of code inside the method::
-            //private void Log(string message, LogLevel level, bool reportModification)
-            var debugSettings = new DebugSettings
-            {
-                VerboseLogging = true
-            };
-            var logger = new DynamoLogger(debugSettings, pathManager.LogDirectory);
+            // Get the dynamo logger in non-test mode, as we write the logs
+            // to dynamo console and to a file only in non-test mode.
+            logger = GetDynamoLoggerWithTestModeFalse();
 
             //Act
             logger.LogWarning("Testing Logging Warning", WarningLevel.Error);
@@ -77,7 +77,7 @@ public void test_dynamologger_logger()
             logger.LogError("Testing Logging Error","Error Details");
 
             //Assert
-            //Check if the logged info was inserted inside the logged text (the log file cannot be opened due that is being used by the base class)
+            //Check if the logged info is stored in the LogText property (the log file cannot be opened due that is being used by the base class)
             Assert.IsTrue(logger.LogText.Contains("Testing Logging Warning"));
 
             logger.Dispose();
diff --git a/test/DynamoCoreTests/Migration/WorkspaceMigrationsTests.cs b/test/DynamoCoreTests/Migration/WorkspaceMigrationsTests.cs
@@ -1,7 +1,8 @@
-﻿using Dynamo.Migration;
-using NUnit.Framework;
+﻿using System;
 using System.IO;
 using System.Xml;
+using Dynamo.Migration;
+using NUnit.Framework;
 
 namespace Dynamo.Tests.Migrations
 {
@@ -15,21 +16,34 @@ class WorkspaceMigrationsTests : DynamoModelTestBase
         [Category("UnitTests")]
         public void TestWorkspaceMigrations()
         {
+            string consoleOutput;
+
             //Arrange
             string openPath = Path.Combine(TestDirectory, @"core\NodeStates.dyn");
             RunModel(openPath);
             string logFileText = string.Empty;
             XmlDocument xmlDoc = new XmlDocument();
 
-            //Act
-            //Create a instance of WorkspaceMigration and call the function that writes to the log
-            var workMigration = new WorkspaceMigrations(CurrentDynamoModel);
-            workMigration.Migrate_0_5_3_to_0_6_0(xmlDoc);
-            var currentLoggerPath = CurrentDynamoModel.Logger.LogPath;
+            using (StringWriter stringWriter = new StringWriter())
+            {
+                TextWriter standardOutput = Console.Out;
+
+                // Set the console out to a string object to verify the log message.
+                Console.SetOut(stringWriter);
+
+                //Act
+                //Create a instance of WorkspaceMigration and call the function that writes to the log
+                var workMigration = new WorkspaceMigrations(CurrentDynamoModel);
+                workMigration.Migrate_0_5_3_to_0_6_0(xmlDoc);
+
+                consoleOutput = stringWriter.ToString();
+
+                // Set the console out back to std out. 
+                Console.SetOut(standardOutput);
+            }
 
-            //Assert
-            Assert.IsTrue(File.Exists(currentLoggerPath));//Check that the log was created successfully
-            Assert.IsTrue(CurrentDynamoModel.Logger.LogText.Contains("migration from 0.5.3.x to 0.6.1.x"));//Checks that the log text contains the migration info
+            //Checks that the console output text contains the migration info
+            Assert.IsTrue(consoleOutput.Contains("migration from 0.5.3.x to 0.6.1.x"));
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -570,7 +570,7 @@ protected DynamoModel(IStartConfiguration config)`
`570`	`570`	`IsHeadless = config.IsHeadless;`
`571`	`571`
`572`	`572`	`DebugSettings = new DebugSettings();`
`573`		`- Logger = new DynamoLogger(DebugSettings, pathManager.LogDirectory);`
	`573`	`+ Logger = new DynamoLogger(DebugSettings, pathManager.LogDirectory, IsTestMode);`
`574`	`574`
`575`	`575`	`foreach (var exception in exceptions)`
`576`	`576`	`{`