SmartEnum/test/SmartEnum.JsonNet.UnitTests/SmartFlagEnumNameConverterTests.cs at 48abb916bb83b7c76c8cf5c1f00db55bf52a2202 · ardalis/SmartEnum · 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
using FluentAssertions;
using Newtonsoft.Json;
using System;
using Xunit;

namespace Ardalis.SmartEnum.JsonNet.UnitTests
{
    public class SmartFlagEnumNameConverterTests
    {
        public class FlagTestClass
        {
            [JsonConverter(typeof(SmartFlagEnumNameConverter<FlagTestEnums.FlagTestEnumInt16, short>))]
            public FlagTestEnums.FlagTestEnumInt16 Int16 { get; set; }

            [JsonConverter(typeof(SmartFlagEnumNameConverter<FlagTestEnums.FlagTestEnumInt32, int>))]
            public FlagTestEnums.FlagTestEnumInt32 Int32 { get; set; }

            [JsonConverter(typeof(SmartFlagEnumNameConverter<FlagTestEnums.FlagTestEnumDouble, double>))]
            public FlagTestEnums.FlagTestEnumDouble Double { get; set; }

            [JsonConverter(typeof(SmartFlagEnumNameConverter<FlagTestEnums.FlagTestEnumGuid, Guid>))]
            public FlagTestEnums.FlagTestEnumGuid Guid { get; set; }
        }

        private static readonly FlagTestClass TestInstance = new FlagTestClass
        {
            Int16 = FlagTestEnums.FlagTestEnumInt16.Instance,
            Int32 = FlagTestEnums.FlagTestEnumInt32.Instance,
            Double = FlagTestEnums.FlagTestEnumDouble.Instance,
            Guid = FlagTestEnums.FlagTestEnumGuid.Instance
        };

        private static readonly string JsonString = JsonConvert.SerializeObject(new
        {
            Int16 = "Instance",
            Int32 = "Instance",
            Double = "Instance",
            Guid = "Instance"
        }, Formatting.Indented);

        [Fact]
        public void SerializesNames()
        {
            var json = JsonConvert.SerializeObject(TestInstance, Formatting.Indented);

            json.Should().Be(JsonString);
        }

        [Fact]
        public void DeserializesNames()
        {
            var obj = JsonConvert.DeserializeObject<FlagTestClass>(JsonString);

            obj.Int16.Should().BeSameAs(FlagTestEnums.FlagTestEnumInt16.Instance);
            obj.Int32.Should().BeSameAs(FlagTestEnums.FlagTestEnumInt32.Instance);
            obj.Double.Should().BeSameAs(FlagTestEnums.FlagTestEnumDouble.Instance);
            obj.Guid.Should().BeSameAs(FlagTestEnums.FlagTestEnumGuid.Instance);
        }

        [Fact]
        public void DeserializesNullByDefault()
        {
            const string json = @"{}";

            var obj = JsonConvert.DeserializeObject<FlagTestClass>(json);

            obj.Int16.Should().BeNull();
            obj.Int32.Should().BeNull();
            obj.Double.Should().BeNull();
            obj.Guid.Should().BeNull();
        }

        [Fact]
        public void DeserializeThrowsWhenNotFound()
        {
            const string json = @"{ ""int32"": ""Not Found"" }";

            Action act = () => JsonConvert.DeserializeObject<FlagTestClass>(json);

            act.Should()
                .Throw<JsonSerializationException>()
                .WithMessage($@"Error converting value 'Not Found' to a smart flag enum.")
                .WithInnerException<SmartEnumNotFoundException>()
                .WithMessage($@"No {nameof(FlagTestEnums.FlagTestEnumInt32)} with Name ""Not Found"" found.");
        }

        [Fact]
        public void DeserializeThrowsWhenNull()
        {
            const string json = @"{ ""int16"": null }";

            Action act = () => JsonConvert.DeserializeObject<FlagTestClass>(json);

            act.Should()
                .Throw<JsonSerializationException>()
                .WithMessage($@"Unexpected token Null when parsing a smart flag enum.");
        }
    }
}