GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/teams.net

Public

mirrored fromhttps://github.com/microsoft/teams.netAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
22df127116ef02cc5a31f714736cc25de03d7f9a

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

teams.net/Tests/Microsoft.Teams.Common.Tests/Logging

Tests/Microsoft.Teams.Common.Tests/Logging/ConsoleLoggerTests.cs

355lines · modecode

RawDownload
Latest commit unavailable.
1using System.Reflection;
2using System.Text;
3
4using Microsoft.Teams.Common.Logging;
5using Microsoft.Teams.Common.Text;
6
7namespace Microsoft.Teams.Common.Tests.Logging;
8
9public class ConsoleLoggerTests
10{
11
12 [Fact]
13 public void ConsoleLogger_DefaultProps()
14 {
15 // Arrange
16 var expectedName = Assembly.GetEntryAssembly()?.GetName().Name ?? "Microsoft.Teams";
17
18 // Act
19 var logger = new ConsoleLogger();
20
21 // Assert
22 Assert.NotNull(logger);
23 Assert.Equal(typeof(ConsoleLogger), logger.GetType());
24 Assert.True(logger.IsEnabled(LogLevel.Error));
25 Assert.True(logger.IsEnabled(LogLevel.Warn));
26 Assert.True(logger.IsEnabled(LogLevel.Info));
27 Assert.False(logger.IsEnabled(LogLevel.Debug));
28 Assert.Equal(expectedName, logger.Name);
29 Assert.Equal(LogLevel.Info, logger.Level);
30 }
31
32 [Fact]
33 public void ConsoleLogger_RespectsLogEnvironmentVariable()
34 {
35 // Arrange
36 Environment.SetEnvironmentVariable("LOG_LEVEL", "Warn");
37
38 // Act
39 var logger = new ConsoleLogger("TestLogger");
40
41 // Assert
42 Assert.False(logger.IsEnabled(LogLevel.Debug));
43 Assert.False(logger.IsEnabled(LogLevel.Info));
44 Assert.True(logger.IsEnabled(LogLevel.Warn));
45
46 // Cleanup
47 Environment.SetEnvironmentVariable("LOG_LEVEL", null);
48 }
49
50 [Fact]
51 public void ConsoleLogger_LoggingSettings_NonMatchingPattern()
52 {
53 // Arrange
54 var expectedName = Assembly.GetEntryAssembly()?.GetName().Name ?? "Microsoft.Teams";
55 var loggingSettings = new LoggingSettings();
56 loggingSettings.Enable = "Tests*";
57 loggingSettings.Level = LogLevel.Error;
58 // Act
59 var logger = new ConsoleLogger(loggingSettings);
60
61 // Assert
62 Assert.NotNull(logger);
63 Assert.Equal(typeof(ConsoleLogger), logger.GetType());
64 Assert.Equal(expectedName, logger.Name);
65 Assert.False(logger.IsEnabled(LogLevel.Error));
66 }
67
68 [Fact]
69 public void ConsoleLogger_LoggingSettings_PatternMatchingName()
70 {
71 // Arrange
72 var expectedName = Assembly.GetEntryAssembly()?.GetName().Name ?? "Microsoft.Teams";
73 var loggingSettings = new LoggingSettings();
74 loggingSettings.Enable = $"{expectedName}*";
75 loggingSettings.Level = LogLevel.Warn;
76
77 // Act
78 var logger = new ConsoleLogger(loggingSettings);
79
80 // Assert
81 Assert.NotNull(logger);
82 Assert.Equal(expectedName, logger.Name);
83 Assert.Equal(LogLevel.Warn, logger.Level);
84 Assert.Equal(typeof(ConsoleLogger), logger.GetType());
85 Assert.True(logger.IsEnabled(LogLevel.Warn));
86 }
87
88 [Fact]
89 public void ConsoleLogger_Create()
90 {
91 // Arrange
92 var logger = new ConsoleLogger();
93 var message = "Test info message";
94
95 // Act
96 ConsoleLogger expectedConsoleLogger = (ConsoleLogger)logger.Create(message);
97
98 // Assert
99 Assert.Equal(message, expectedConsoleLogger.Name);
100 Assert.Equal(LogLevel.Info, expectedConsoleLogger.Level);
101 }
102
103 [Fact]
104 public void ConsoleLogger_Create_Interface()
105 {
106 // Arrange
107 var logger = new ConsoleLogger();
108 var message = "Test error message";
109 // Act
110 var expectedLogger = logger.Create(message);
111
112 // Assert
113 Assert.NotNull(expectedLogger);
114 Assert.Equal(typeof(ConsoleLogger), expectedLogger.GetType());
115 Assert.Equal(logger.GetType(), expectedLogger.GetType());
116 Assert.Equal("Microsoft.Teams.Common.Logging.ConsoleLogger", expectedLogger.ToString());
117 }
118
119 [Fact]
120 public void ConsoleLogger_Child_CreatesChildLoggerWithCorrectNameAndLevel()
121 {
122 // Arrange
123 var parentLogger = new ConsoleLogger("ParentLogger", LogLevel.Warn);
124
125 // Act
126 var childLogger = (ConsoleLogger)parentLogger.Child("Child");
127
128 // Assert
129 Assert.NotNull(childLogger);
130 Assert.Equal("ParentLogger.Child", childLogger.Name);
131 Assert.Equal(parentLogger.Level, childLogger.Level);
132 Assert.Equal(parentLogger.GetType(), childLogger.GetType());
133 }
134
135
136 [Fact]
137 public void ConsoleLogger_Peer_CreatesChildLoggerWithDefaultNameAndLevel()
138 {
139 // Arrange
140 var parentLogger = new ConsoleLogger("ParentLogger", LogLevel.Warn);
141
142 // Act
143 var peerLogger = (ConsoleLogger)parentLogger.Peer("Peer");
144
145 // Assert
146 Assert.NotNull(peerLogger);
147 Assert.Equal(".Peer", peerLogger.Name);
148 Assert.Equal(parentLogger.Level, peerLogger.Level);
149 Assert.Equal(parentLogger.GetType(), peerLogger.GetType());
150 }
151
152
153 [Fact]
154 public void ConsoleLogger_Peer_CreatesChildLoggerWithCorrectNamespaceNameAndLevel()
155 {
156 // Arrange
157 var parentLogger = new ConsoleLogger("Microsoft.Teams.ConsoleLogs", LogLevel.Warn);
158
159 // Act
160 var peerLogger = (ConsoleLogger)parentLogger.Peer("PeerLogs");
161
162 // Assert
163 Assert.NotNull(peerLogger);
164 // TODO: Check what name should be expected when Consolelogger is created with "Microsoft", currently it is ".PeerLogs"
165 Assert.Equal("Microsoft.Teams.PeerLogs", peerLogger.Name);
166 Assert.Equal(parentLogger.Level, peerLogger.Level);
167 Assert.Equal(parentLogger.GetType(), peerLogger.GetType());
168 }
169
170 [Fact]
171 public void ConsoleLogger_SetLevel_UpdatesLevelAndReturnsSelf()
172 {
173 // Arrange
174 var logger = new ConsoleLogger("TestLogger", LogLevel.Info);
175
176 // Act
177 var returnedLogger = logger.SetLevel(LogLevel.Debug);
178
179 // Assert
180 Assert.Equal(LogLevel.Debug, logger.Level);
181 Assert.Same(logger, returnedLogger);
182 Assert.True(logger.IsEnabled(LogLevel.Debug));
183 Assert.True(logger.IsEnabled(LogLevel.Info));
184 Assert.True(logger.IsEnabled(LogLevel.Warn));
185 Assert.True(logger.IsEnabled(LogLevel.Error));
186 }
187
188 [Fact]
189 public void ConsoleLogger_SetLevel_UpdatesLevelErrorOnly()
190 {
191 // Arrange
192 var logger = new ConsoleLogger("TestLogger", LogLevel.Info);
193
194 // Act
195 var returnedLogger = logger.SetLevel(LogLevel.Error);
196
197 // Assert
198 Assert.Equal(LogLevel.Error, logger.Level);
199 Assert.Same(logger, returnedLogger);
200 Assert.False(logger.IsEnabled(LogLevel.Debug));
201 Assert.False(logger.IsEnabled(LogLevel.Info));
202 Assert.False(logger.IsEnabled(LogLevel.Warn));
203 Assert.True(logger.IsEnabled(LogLevel.Error));
204 }
205
206 [Fact]
207 public void ConsoleLogger_LogsDebugMessageToConsole()
208 {
209 // Arrange
210 var logger = new ConsoleLogger("TestLogger", LogLevel.Debug);
211
212 using var sw = new StringWriter();
213 var originalOut = Console.Out;
214 Console.SetOut(sw);
215
216 try
217 {
218 // Act
219 logger.Debug("registered function error ");
220
221 // Assert
222 var output = sw.ToString().Replace("\r\n", "\n"); ;
223 Assert.Contains("DEBUG", output, StringComparison.OrdinalIgnoreCase);
224 Assert.Contains("TestLogger", output);
225 var expectedString = "\u001b[35m\u001b[1m[DEBUG]\u001b[22m\u001b[0m \u001b[35m\u001b[1mTestLogger\u001b[22m\u001b[0m\u001b[0m registered function error \n";
226
227 Assert.Equal(expectedString, output);
228 }
229 finally
230 {
231 Console.SetOut(originalOut);
232 }
233 }
234
235 [Fact]
236 public void ConsoleLogger_LogsInfoMessageToConsole()
237 {
238 // Arrange
239 var logger = new ConsoleLogger("TestLogger", LogLevel.Info);
240 using var sw = new StringWriter();
241 var originalOut = Console.Out;
242 Console.SetOut(sw);
243
244 try
245 {
246 // Act
247 logger.Info("Starting to connect ");
248
249 // Assert
250 var output = sw.ToString().Replace("\r\n", "\n"); ;
251 Assert.Contains("INFO", output, StringComparison.OrdinalIgnoreCase);
252 Assert.Contains("TestLogger", output);
253 var expectedString = "\u001b[36m\u001b[1m[INFO]\u001b[22m\u001b[0m \u001b[36m\u001b[1mTestLogger\u001b[22m\u001b[0m\u001b[0m Starting to connect \n";
254
255 Assert.Equal(expectedString, output);
256 }
257 finally
258 {
259 Console.SetOut(originalOut);
260 }
261 }
262
263 [Fact]
264 public void ConsoleLogger_LogsWarningMessageToConsole()
265 {
266 // Arrange
267 var logger = new ConsoleLogger("TestLogger", LogLevel.Warn);
268 var testMessage = new StringBuilder()
269 .Bold(
270 new StringBuilder()
271 .Yellow("⚠️ Devtools ⚠️")
272 .ToString()
273 );
274 using var sw = new StringWriter();
275 var originalOut = Console.Out;
276 Console.SetOut(sw);
277
278 try
279 {
280 // Act
281 logger.Warn(testMessage);
282
283 // Assert
284 var output = sw.ToString().Replace("\r\n", "\n"); ;
285 Assert.Contains("WARN", output, StringComparison.OrdinalIgnoreCase);
286 Assert.Contains("TestLogger", output);
287 var expectedString = "\u001b[33m\u001b[1m[WARN]\u001b[22m\u001b[0m \u001b[33m\u001b[1mTestLogger\u001b[22m\u001b[0m\u001b[0m \u001b[1m\u001b[33m⚠️ Devtools ⚠️\u001b[0m\u001b[22m\n";
288
289 Assert.Equal(expectedString, output);
290 }
291 finally
292 {
293 Console.SetOut(originalOut);
294 }
295 }
296
297 [Fact]
298 public void ConsoleLogger_DoesNotLogWarningMessageWhenWarnLevenNotEnabled()
299 {
300 // Arrange
301 var logger = new ConsoleLogger("TestLogger", LogLevel.Error);
302 var testMessage = "Some warning";
303 using var sw = new StringWriter();
304 var originalOut = Console.Out;
305 Console.SetOut(sw);
306
307 try
308 {
309 // Act
310 logger.Warn(testMessage);
311
312 // Assert
313 var output = sw.ToString();
314 Assert.Empty(output);
315 }
316 finally
317 {
318 Console.SetOut(originalOut);
319 }
320 }
321
322 [Fact]
323 public void ConsoleLogger_LogsErrorMessageToConsole()
324 {
325 // Arrange
326 var logger = new ConsoleLogger("TestLogger");
327 var testMessage = new StringBuilder()
328 .Bold(
329 new StringBuilder()
330 .Red("!! Error !!")
331 .ToString()
332 );
333 using var sw = new StringWriter();
334 var originalOut = Console.Out;
335 Console.SetOut(sw);
336
337 try
338 {
339 // Act
340 logger.Error(testMessage);
341
342 // Assert
343 var output = sw.ToString().Replace("\r\n", "\n"); ;
344 Assert.Contains("ERROR", output, StringComparison.OrdinalIgnoreCase);
345 Assert.Contains("TestLogger", output);
346 var expectedString = "\u001b[31m\u001b[1m[ERROR]\u001b[22m\u001b[0m \u001b[31m\u001b[1mTestLogger\u001b[22m\u001b[0m\u001b[0m \u001b[1m\u001b[31m!! Error !!\u001b[0m\u001b[22m\n";
347
348 Assert.Equal(expectedString, output);
349 }
350 finally
351 {
352 Console.SetOut(originalOut);
353 }
354 }
355}