SNOW-990111: Add easy logging improvements

Snowflake.Data.Tests/UnitTests/Configuration/EasyLoggingConfigFinderTest.cs

@@ -4,6 +4,8 @@
 
 using System;
 using System.IO;
+using System.Runtime.InteropServices;
+using Mono.Unix;
 using Moq;
 using NUnit.Framework;
 using Snowflake.Data.Configuration;
@@ -17,13 +19,19 @@ public class EasyLoggingConfigFinderTest
         private const string InputConfigFilePath = "input_config.json";
         private const string EnvironmentalConfigFilePath = "environmental_config.json";
         private const string HomeDirectory = "/home/user";
-        private static readonly string s_driverConfigFilePath = Path.Combine(".", EasyLoggingConfigFinder.ClientConfigFileName);
+        private const string DriverDirectory = ".";
+        private static readonly string s_driverConfigFilePath = Path.Combine(DriverDirectory, EasyLoggingConfigFinder.ClientConfigFileName);
         private static readonly string s_homeConfigFilePath = Path.Combine(HomeDirectory, EasyLoggingConfigFinder.ClientConfigFileName);
-        private static readonly string s_tempConfigFilePath = Path.Combine(Path.GetTempPath(), EasyLoggingConfigFinder.ClientConfigFileName);
 
         [ThreadStatic]
         private static Mock<FileOperations> t_fileOperations;
 
+        [ThreadStatic]
+        private static Mock<UnixOperations> t_unixOperations;
+
+        [ThreadStatic]
+        private static Mock<DirectoryOperations> t_directoryOperations;
+
         [ThreadStatic]
         private static Mock<EnvironmentOperations> t_environmentOperations;
 
@@ -34,8 +42,11 @@ public class EasyLoggingConfigFinderTest
         public void Setup()
         {
             t_fileOperations = new Mock<FileOperations>();
+            t_unixOperations = new Mock<UnixOperations>();
+            t_directoryOperations = new Mock<DirectoryOperations>();
             t_environmentOperations = new Mock<EnvironmentOperations>();
-            t_finder = new EasyLoggingConfigFinder(t_fileOperations.Object, t_environmentOperations.Object);
+            t_finder = new EasyLoggingConfigFinder(t_fileOperations.Object, t_unixOperations.Object, t_directoryOperations.Object, t_environmentOperations.Object);
+            MockDirectoriesExist();
             MockHomeDirectory();
         }
 
@@ -46,7 +57,6 @@ public void TestThatTakesFilePathFromTheInput()
             MockFileFromEnvironmentalVariable();
             MockFileOnDriverPath();
             MockFileOnHomePath();
-            MockFileOnTempPath();
 
             // act
             var filePath = t_finder.FindConfigFilePath(InputConfigFilePath);
@@ -65,7 +75,6 @@ public void TestThatTakesFilePathFromEnvironmentVariableIfInputNotPresent(
             MockFileFromEnvironmentalVariable();
             MockFileOnDriverPath();
             MockFileOnHomePath();
-            MockFileOnTempPath();
 
             // act
             var filePath = t_finder.FindConfigFilePath(inputFilePath);
@@ -80,7 +89,6 @@ public void TestThatTakesFilePathFromDriverLocationWhenNoInputParameterNorEnviro
             // arrange
             MockFileOnDriverPath();
             MockFileOnHomePath();
-            MockFileOnTempPath();
 
             // act
             var filePath = t_finder.FindConfigFilePath(null);
@@ -94,7 +102,6 @@ public void TestThatTakesFilePathFromHomeLocationWhenNoInputParamEnvironmentVarN
         {
             // arrange
             MockFileOnHomePath();
-            MockFileOnTempPath();
 
             // act
             var filePath = t_finder.FindConfigFilePath(null);
@@ -104,16 +111,37 @@ public void TestThatTakesFilePathFromHomeLocationWhenNoInputParamEnvironmentVarN
         }
 
         [Test]
-        public void TestThatTakesFilePathFromTempDirectoryWhenNoOtherWaysPossible()
+        public void TestThatTakesFilePathFromHomeDirectoryWhenNoOtherWaysPossible()
         {
             // arrange
-            MockFileOnTempPath();
-            
+            MockFileOnHomePath();
+
             // act
             var filePath = t_finder.FindConfigFilePath(null);
-
+
+            // assert
+            Assert.AreEqual(s_homeConfigFilePath, filePath);
+        }
+
+        [Test]
+        public void TestThatConfigFileIsNotUsedIfOthersCanModifyTheConfigFile()
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                Assert.Ignore("skip test on Windows");
+            }
+
+            // arrange
+            MockFileOnHomePath();
+            MockHasFlagReturnsTrue();
+
+            // act
+            var thrown = Assert.Throws<Exception>(() => t_finder.FindConfigFilePath(null));
+
             // assert
-            Assert.AreEqual(s_tempConfigFilePath, filePath);
+            Assert.IsNotNull(thrown);
+            Assert.AreEqual(thrown.Message, $"Error due to other users having permission to modify the config file: {s_homeConfigFilePath}");
+            t_unixOperations.Verify(u => u.SetFileInfo(s_homeConfigFilePath), Times.Once);
         }
 
         [Test]
@@ -139,13 +167,29 @@ public void TestThatDoesNotFailWhenSearchForOneOfDirectoriesFails()
             Assert.IsNull(filePath);
             t_environmentOperations.Verify(e => e.GetFolderPath(Environment.SpecialFolder.UserProfile), Times.Once);
         }
-        
+
         [Test]
-        public void TestThatDoesNotFailWhenOneOfDirectoriesNotDefined()
+        public void TestThatDoesNotFailWhenHomeDirectoryReturnsNull()
         {
             // arrange
             MockHomeDirectoryReturnsNull();
 
+            // act
+            var filePath = t_finder.FindConfigFilePath(null);
+
+            // assert
+            Assert.IsNull(filePath);
+            t_environmentOperations.Verify(e => e.GetFolderPath(Environment.SpecialFolder.UserProfile), Times.Once);
+        }
+
+        [Test]
+        public void TestThatDoesNotFailWhenHomeDirectoryDoesNotExist()
+        {
+            // arrange
+            MockFileOnHomePath();
+            MockHomeDirectoryDoesNotExist();
+            MockFileOnHomePathDoesNotExist();
+
             // act
             var filePath = t_finder.FindConfigFilePath(null);
 
@@ -154,6 +198,22 @@ public void TestThatDoesNotFailWhenOneOfDirectoriesNotDefined()
             t_environmentOperations.Verify(e => e.GetFolderPath(Environment.SpecialFolder.UserProfile), Times.Once);
         }
 
+        private static void MockDirectoriesExist()
+        {
+            t_directoryOperations
+                .Setup(d => d.Exists(
+                    It.Is<string>(dir => dir.Equals(DriverDirectory) || dir.Equals(HomeDirectory))))
+                .Returns(true);
+        }
+
+        private static void MockHasFlagReturnsTrue()
+        {
+            t_unixOperations
+                .Setup(f => f.CheckFileHasPermissions(
+                    It.Is<FileAccessPermissions>(p =>  p.Equals(FileAccessPermissions.GroupWrite | FileAccessPermissions.OtherWrite))))
+                .Returns(true);
+        }
+
         private static void MockHomeDirectory()
         {
             t_environmentOperations
@@ -168,6 +228,20 @@ private static void MockHomeDirectoryFails()
                 .Throws(() => new Exception("No home directory"));
         }
 
+        private static void MockHomeDirectoryDoesNotExist()
+        {
+            t_directoryOperations
+                .Setup(d => d.Exists(HomeDirectory))
+                .Returns(false);
+        }
+
+        private static void MockFileOnHomePathDoesNotExist()
+        {
+            t_fileOperations
+                .Setup(f => f.Exists(s_homeConfigFilePath))
+                .Returns(false);
+        }
+
         private static void MockHomeDirectoryReturnsNull()
         {
             t_environmentOperations
@@ -195,12 +269,5 @@ private static void MockFileOnHomePath()
                 .Setup(f => f.Exists(s_homeConfigFilePath))
                 .Returns(true);
         }
-
-        private static void MockFileOnTempPath()
-        {
-            t_fileOperations
-                .Setup(f => f.Exists(s_tempConfigFilePath))
-                .Returns(true);            
-        }
     }
 }

Snowflake.Data.Tests/UnitTests/Logger/EasyLoggerManagerTest.cs

@@ -5,6 +5,7 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using NUnit.Framework;
 using Snowflake.Data.Configuration;
 using Snowflake.Data.Core;
@@ -21,7 +22,7 @@ public class EasyLoggerManagerTest
         private const string WarnMessage = "Easy logging Warn message";
         private const string ErrorMessage = "Easy logging Error message";
         private const string FatalMessage = "Easy logging Fatal message";
-        private static readonly string s_logsDirectory = Path.GetTempPath();
+        private static readonly string s_logsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
 
         [ThreadStatic]
         private static string t_directoryLogPath;
@@ -92,6 +93,38 @@ public void TestThatLogsToProperFileWithProperLogLevelOnly()
             Assert.That(logLines, Has.Exactly(1).Matches<string>(s => s.Contains(FatalMessage)));
         }
 
+        [Test]
+        public void TestThatOnlyUnknownFieldsAreLogged()
+        {
+            // arrange
+            string expectedFakeLogField = "fake_log_field";
+            string ConfigWithUnknownFields = $@"{{
+                    ""common"": {{
+                        ""LOG_LEVEL"": ""warn"",
+                        ""lOg_PaTh"": ""path"",
+                        ""{expectedFakeLogField}_1"": ""abc"",
+                        ""{expectedFakeLogField}_2"": ""123""
+                    }}
+                }}";
+            var configFilePath = Guid.NewGuid().ToString() + ".json";
+            using (var writer = File.CreateText(configFilePath))
+            {
+                writer.Write(ConfigWithUnknownFields);
+            }
+            EasyLoggerManager.Instance.ReconfigureEasyLogging(EasyLoggingLogLevel.Warn, t_directoryLogPath);
+            var parser = new EasyLoggingConfigParser();
+
+            // act
+            parser.Parse(configFilePath);
+
+            // assert
+            var logLines = File.ReadLines(FindLogFilePath(t_directoryLogPath));
+            Assert.That(logLines, Has.Exactly(2).Matches<string>(s => s.Contains($"Unknown field from config: {expectedFakeLogField}")));
+
+            // cleanup
+            File.Delete(configFilePath);
+        }
+
         private static string RandomLogsDirectoryPath()
         {
             var randomName = Path.GetRandomFileName();