Scarlet.System.Text.Json.DateTimeConverter/src/Scarlet.System.Text.Json.DateTimeConverter.Tests/DateTimeConverterFactoryHelperTests.cs at 0269fdb584568efd0c7ed418dcefb1b87b1fcf3d · ScarletKuro/Scarlet.System.Text.Json.DateTimeConverter · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
using System.Text.Json;
using System.Text.Json.Serialization;

namespace Scarlet.System.Text.Json.DateTimeConverter.Tests;

/// <summary>
/// Unit tests for DateTimeConverterFactoryHelper to ensure full code coverage.
/// </summary>
public class DateTimeConverterFactoryHelperTests
{
    private const string TestDateFormat = "yyyy-MM-dd";
    private const string TestTimeFormat = "HH:mm:ss";

    [Fact]
    public void CreateConverter_DateTime_ReturnsDateTimeConverter()
    {
        // Act
        var converter = DateTimeConverterFactoryHelper.CreateConverter(typeof(DateTime), TestDateFormat);

        // Assert
        Assert.NotNull(converter);
        Assert.IsType<Converters.DateTimeConverter>(converter);
    }

    [Fact]
    public void CreateConverter_NullableDateTime_ReturnsDateTimeNullableConverter()
    {
        // Act
        var converter = DateTimeConverterFactoryHelper.CreateConverter(typeof(DateTime?), TestDateFormat);

        // Assert
        Assert.NotNull(converter);
        Assert.IsType<Converters.DateTimeNullableConverter>(converter);
    }

    [Fact]
    public void CreateConverter_DateTimeOffset_ReturnsDateTimeOffsetConverter()
    {
        // Act
        var converter = DateTimeConverterFactoryHelper.CreateConverter(typeof(DateTimeOffset), TestDateFormat);

        // Assert
        Assert.NotNull(converter);
        Assert.IsType<Converters.DateTimeOffsetConverter>(converter);
    }

    [Fact]
    public void CreateConverter_NullableDateTimeOffset_ReturnsDateTimeOffsetNullableConverter()
    {
        // Act
        var converter = DateTimeConverterFactoryHelper.CreateConverter(typeof(DateTimeOffset?), TestDateFormat);

        // Assert
        Assert.NotNull(converter);
        Assert.IsType<Converters.DateTimeOffsetNullableConverter>(converter);
    }

    [Fact]
    public void CreateConverter_DateOnly_ReturnsDateOnlyConverter()
    {
        // Act
        var converter = DateTimeConverterFactoryHelper.CreateConverter(typeof(DateOnly), TestDateFormat);

        // Assert
        Assert.NotNull(converter);
        Assert.IsType<Converters.DateOnlyConverter>(converter);
    }

    [Fact]
    public void CreateConverter_NullableDateOnly_ReturnsDateOnlyNullableConverter()
    {
        // Act
        var converter = DateTimeConverterFactoryHelper.CreateConverter(typeof(DateOnly?), TestDateFormat);

        // Assert
        Assert.NotNull(converter);
        Assert.IsType<Converters.DateOnlyNullableConverter>(converter);
    }

    [Fact]
    public void CreateConverter_TimeOnly_ReturnsTimeOnlyConverter()
    {
        // Act
        var converter = DateTimeConverterFactoryHelper.CreateConverter(typeof(TimeOnly), TestTimeFormat);

        // Assert
        Assert.NotNull(converter);
        Assert.IsType<Converters.TimeOnlyConverter>(converter);
    }

    [Fact]
    public void CreateConverter_NullableTimeOnly_ReturnsTimeOnlyNullableConverter()
    {
        // Act
        var converter = DateTimeConverterFactoryHelper.CreateConverter(typeof(TimeOnly?), TestTimeFormat);

        // Assert
        Assert.NotNull(converter);
        Assert.IsType<Converters.TimeOnlyNullableConverter>(converter);
    }

    [Fact]
    public void CreateConverter_UnsupportedType_ThrowsNotSupportedException()
    {
        // Act & Assert
        var exception = Assert.Throws<NotSupportedException>(() =>
            DateTimeConverterFactoryHelper.CreateConverter(typeof(string), TestDateFormat));

        Assert.Contains("System.String", exception.Message);
        Assert.Contains("DateTimeConverterFactoryHelper", exception.Message);
    }

    [Fact]
    public void CreateConverter_AnotherUnsupportedType_ThrowsNotSupportedException()
    {
        // Act & Assert
        var exception = Assert.Throws<NotSupportedException>(() =>
            DateTimeConverterFactoryHelper.CreateConverter(typeof(int), TestDateFormat));

        Assert.Contains("System.Int32", exception.Message);
        Assert.Contains("DateTimeConverterFactoryHelper", exception.Message);
    }

    [Fact]
    public void CreateConverter_NullType_ThrowsArgumentNullException()
    {
        // Act & Assert
        Assert.Throws<ArgumentNullException>(() =>
            DateTimeConverterFactoryHelper.CreateConverter(null!, TestDateFormat));
    }
}