Skip to content

Commit fe360e1

Browse files
hjgracahjgraca
committed
test coverage
1 parent 738dbf5 commit fe360e1

File tree

3 files changed

+354
-0
lines changed

3 files changed

+354
-0
lines changed

‎libraries/tests/AWS.Lambda.Powertools.Common.Tests/ConsoleWrapperTests.cs

Lines changed: 98 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -78,4 +78,102 @@ public void OverrideLambdaLogger_Should_Override_Console_Out()
7878
Console.SetOut(originalOut);
7979
}
8080
}
81+
82+
[Fact]
83+
public void WriteLine_WritesMessageToConsole()
84+
{
85+
// Arrange
86+
var consoleWrapper = new ConsoleWrapper();
87+
var originalOutput = Console.Out;
88+
using var stringWriter = new StringWriter();
89+
Console.SetOut(stringWriter);
90+
91+
try
92+
{
93+
// Act
94+
consoleWrapper.WriteLine("Test message");
95+
96+
// Assert
97+
var output = stringWriter.ToString();
98+
Assert.Contains("Test message", output);
99+
}
100+
finally
101+
{
102+
// Restore original output
103+
Console.SetOut(originalOutput);
104+
}
105+
}
106+
107+
[Fact]
108+
public void Error_WritesMessageToErrorOutput()
109+
{
110+
// Arrange
111+
var consoleWrapper = new ConsoleWrapper();
112+
var writer = new StringWriter();
113+
114+
// This sets _override = true, preventing Error from creating a new stream
115+
ConsoleWrapper.SetOut(writer);
116+
Console.SetError(writer);
117+
118+
// Act
119+
consoleWrapper.Error("Error message");
120+
writer.Flush();
121+
122+
// Assert
123+
var output = writer.ToString();
124+
Assert.Contains("Error message", output);
125+
}
126+
127+
[Fact]
128+
public void SetOut_OverridesConsoleOutput()
129+
{
130+
// Arrange
131+
var originalOutput = Console.Out;
132+
using var stringWriter = new StringWriter();
133+
134+
try
135+
{
136+
// Act
137+
typeof(ConsoleWrapper)
138+
.GetMethod("SetOut", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)
139+
?.Invoke(null, new object[] { stringWriter });
140+
141+
Console.WriteLine("Test override");
142+
143+
// Assert
144+
var output = stringWriter.ToString();
145+
Assert.Contains("Test override", output);
146+
}
147+
finally
148+
{
149+
// Restore original output
150+
Console.SetOut(originalOutput);
151+
}
152+
}
153+
154+
[Fact]
155+
public void StaticWriteLine_FormatsLogMessageCorrectly()
156+
{
157+
// Arrange
158+
var originalOutput = Console.Out;
159+
using var stringWriter = new StringWriter();
160+
Console.SetOut(stringWriter);
161+
162+
try
163+
{
164+
// Act
165+
typeof(ConsoleWrapper)
166+
.GetMethod("WriteLine", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static, null, new[] { typeof(string), typeof(string) }, null)
167+
?.Invoke(null, new object[] { "INFO", "Test log message" });
168+
169+
// Assert
170+
var output = stringWriter.ToString();
171+
Assert.Matches(@"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\tINFO\tTest log message", output);
172+
}
173+
finally
174+
{
175+
// Restore original output
176+
Console.SetOut(originalOutput);
177+
}
178+
}
81179
}

‎libraries/tests/AWS.Lambda.Powertools.Logging.Tests/FactoryTests.cs

Lines changed: 148 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,148 @@
1+
using AWS.Lambda.Powertools.Logging.Internal;
2+
using Microsoft.Extensions.Logging;
3+
using NSubstitute;
4+
using Xunit;
5+
6+
namespace AWS.Lambda.Powertools.Logging.Tests;
7+
8+
public class LoggingAspectFactoryTests
9+
{
10+
[Fact]
11+
public void GetInstance_ShouldReturnLoggingAspectInstance()
12+
{
13+
// Act
14+
var result = LoggingAspectFactory.GetInstance(typeof(LoggingAspectFactoryTests));
15+
16+
// Assert
17+
Assert.NotNull(result);
18+
Assert.IsType<LoggingAspect>(result);
19+
}
20+
}
21+
22+
public class PowertoolsLoggerFactoryTests
23+
{
24+
[Fact]
25+
public void Constructor_WithLoggerFactory_CreatesPowertoolsLoggerFactory()
26+
{
27+
// Arrange
28+
var mockFactory = Substitute.For<ILoggerFactory>();
29+
30+
// Act
31+
var factory = new PowertoolsLoggerFactory(mockFactory);
32+
33+
// Assert
34+
Assert.NotNull(factory);
35+
}
36+
37+
[Fact]
38+
public void DefaultConstructor_CreatesPowertoolsLoggerFactory()
39+
{
40+
// Act
41+
var factory = new PowertoolsLoggerFactory();
42+
43+
// Assert
44+
Assert.NotNull(factory);
45+
}
46+
47+
[Fact]
48+
public void Create_WithConfigAction_ReturnsPowertoolsLoggerFactory()
49+
{
50+
// Act
51+
var factory = PowertoolsLoggerFactory.Create(options =>
52+
{
53+
options.Service = "TestService";
54+
});
55+
56+
// Assert
57+
Assert.NotNull(factory);
58+
}
59+
60+
[Fact]
61+
public void Create_WithConfiguration_ReturnsLoggerFactory()
62+
{
63+
// Arrange
64+
var configuration = new PowertoolsLoggerConfiguration
65+
{
66+
Service = "TestService"
67+
};
68+
69+
// Act
70+
var factory = PowertoolsLoggerFactory.Create(configuration);
71+
72+
// Assert
73+
Assert.NotNull(factory);
74+
}
75+
76+
[Fact]
77+
public void CreateBuilder_ReturnsLoggerBuilder()
78+
{
79+
// Act
80+
var builder = PowertoolsLoggerFactory.CreateBuilder();
81+
82+
// Assert
83+
Assert.NotNull(builder);
84+
Assert.IsType<PowertoolsLoggerBuilder>(builder);
85+
}
86+
87+
[Fact]
88+
public void CreateLogger_Generic_ReturnsLogger()
89+
{
90+
// Arrange
91+
var mockFactory = Substitute.For<ILoggerFactory>();
92+
mockFactory.CreateLogger(Arg.Any<string>()).Returns(Substitute.For<ILogger>());
93+
var factory = new PowertoolsLoggerFactory(mockFactory);
94+
95+
// Act
96+
var logger = factory.CreateLogger<PowertoolsLoggerFactoryTests>();
97+
98+
// Assert
99+
Assert.NotNull(logger);
100+
mockFactory.Received(1).CreateLogger(typeof(PowertoolsLoggerFactoryTests).FullName);
101+
}
102+
103+
[Fact]
104+
public void CreateLogger_WithCategory_ReturnsLogger()
105+
{
106+
// Arrange
107+
var mockFactory = Substitute.For<ILoggerFactory>();
108+
mockFactory.CreateLogger("TestCategory").Returns(Substitute.For<ILogger>());
109+
var factory = new PowertoolsLoggerFactory(mockFactory);
110+
111+
// Act
112+
var logger = factory.CreateLogger("TestCategory");
113+
114+
// Assert
115+
Assert.NotNull(logger);
116+
mockFactory.Received(1).CreateLogger("TestCategory");
117+
}
118+
119+
[Fact]
120+
public void CreatePowertoolsLogger_ReturnsPowertoolsLogger()
121+
{
122+
// Arrange
123+
var mockFactory = Substitute.For<ILoggerFactory>();
124+
mockFactory.CreatePowertoolsLogger().Returns(Substitute.For<ILogger>());
125+
var factory = new PowertoolsLoggerFactory(mockFactory);
126+
127+
// Act
128+
var logger = factory.CreatePowertoolsLogger();
129+
130+
// Assert
131+
Assert.NotNull(logger);
132+
mockFactory.Received(1).CreatePowertoolsLogger();
133+
}
134+
135+
[Fact]
136+
public void Dispose_DisposesInnerFactory()
137+
{
138+
// Arrange
139+
var mockFactory = Substitute.For<ILoggerFactory>();
140+
var factory = new PowertoolsLoggerFactory(mockFactory);
141+
142+
// Act
143+
factory.Dispose();
144+
145+
// Assert
146+
mockFactory.Received(1).Dispose();
147+
}
148+
}

‎libraries/tests/AWS.Lambda.Powertools.Logging.Tests/Utilities/Converters.cs

Lines changed: 108 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,108 @@
1+
using System;
2+
using System.Text;
3+
using System.Text.Json;
4+
using System.Text.Json.Serialization;
5+
using AWS.Lambda.Powertools.Logging.Internal.Converters;
6+
using Xunit;
7+
8+
namespace AWS.Lambda.Powertools.Logging.Tests.Utilities;
9+
10+
public class ByteArrayConverterTests
11+
{
12+
private readonly JsonSerializerOptions _options;
13+
14+
public ByteArrayConverterTests()
15+
{
16+
_options = new JsonSerializerOptions();
17+
_options.Converters.Add(new ByteArrayConverter());
18+
}
19+
20+
[Fact]
21+
public void Write_WhenByteArrayIsNull_WritesNullValue()
22+
{
23+
// Arrange
24+
var testObject = new TestClass { Data = null };
25+
26+
// Act
27+
var json = JsonSerializer.Serialize(testObject, _options);
28+
29+
// Assert
30+
Assert.Contains("\"data\":null", json);
31+
}
32+
33+
[Fact]
34+
public void Write_WithByteArray_WritesBase64String()
35+
{
36+
// Arrange
37+
byte[] testData = { 1, 2, 3, 4, 5 };
38+
var testObject = new TestClass { Data = testData };
39+
var expectedBase64 = Convert.ToBase64String(testData);
40+
41+
// Act
42+
var json = JsonSerializer.Serialize(testObject, _options);
43+
44+
// Assert
45+
Assert.Contains($"\"data\":\"{expectedBase64}\"", json);
46+
}
47+
48+
[Fact]
49+
public void Read_WithBase64String_ReturnsByteArray()
50+
{
51+
// Arrange
52+
byte[] expectedData = { 1, 2, 3, 4, 5 };
53+
var base64 = Convert.ToBase64String(expectedData);
54+
var json = $"{{\"data\":\"{base64}\"}}";
55+
56+
// Act
57+
var result = JsonSerializer.Deserialize<TestClass>(json, _options);
58+
59+
// Assert
60+
Assert.Equal(expectedData, result.Data);
61+
}
62+
63+
[Fact]
64+
public void Read_WithInvalidType_ThrowsJsonException()
65+
{
66+
// Arrange
67+
var json = "{\"data\":123}";
68+
69+
// Act & Assert
70+
Assert.Throws<JsonException>(() =>
71+
JsonSerializer.Deserialize<TestClass>(json, _options));
72+
}
73+
74+
[Fact]
75+
public void Read_WithEmptyString_ReturnsEmptyByteArray()
76+
{
77+
// Arrange
78+
var json = "{\"data\":\"\"}";
79+
80+
// Act
81+
var result = JsonSerializer.Deserialize<TestClass>(json, _options);
82+
83+
// Assert
84+
Assert.NotNull(result.Data);
85+
Assert.Empty(result.Data);
86+
}
87+
88+
[Fact]
89+
public void WriteAndRead_RoundTrip_PreservesData()
90+
{
91+
// Arrange
92+
byte[] originalData = Encoding.UTF8.GetBytes("Test data with special chars: !@#$%^&*()");
93+
var testObject = new TestClass { Data = originalData };
94+
95+
// Act
96+
var json = JsonSerializer.Serialize(testObject, _options);
97+
var deserializedObject = JsonSerializer.Deserialize<TestClass>(json, _options);
98+
99+
// Assert
100+
Assert.Equal(originalData, deserializedObject.Data);
101+
}
102+
103+
private class TestClass
104+
{
105+
[JsonPropertyName("data")]
106+
public byte[] Data { get; set; }
107+
}
108+
}

0 commit comments

Comments
 (0)