src/Components/Endpoints/test/TempData/JsonTempDataSerializerTest.cs - main - githubmirror/aspnetcore

src/Components/Endpoints/test/TempData/JsonTempDataSerializerTest.cs
435 строк13 KB
Daria Tiurina
TempData support for Blazor (#64749)
03 фев 2026, 14:53
03 фев 2026, 14:5365468ce
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using System.Text.Json;

namespace Microsoft.AspNetCore.Components.Endpoints;

public class JsonTempDataSerializerTest
{
    private static JsonTempDataSerializer CreateSerializer() => new JsonTempDataSerializer();

    public static TheoryData<Type> InvalidTypes
    {
        get
        {
            return new TheoryData<Type>
                {
                    { typeof(long) },
                    { typeof(long[]) },
                    { typeof(double) },
                    { typeof(double[]) },
                    { typeof(object) },
                    { typeof(object[]) },
                    { typeof(TestItem) },
                    { typeof(List<TestItem>) },
                    { typeof(Dictionary<string, TestItem>) },
                };
        }
    }

    public static TheoryData<Type> InvalidDictionaryKeyTypes
    {
        get
        {
            return new TheoryData<Type>
                {
                    { typeof(Dictionary<int, string>) },
                    { typeof(Dictionary<Uri, Guid>) },
                    { typeof(Dictionary<object, string>) },
                    { typeof(Dictionary<TestItem, TestItem>) }
                };
        }
    }

    public static TheoryData<Type> ValidTypes
    {
        get
        {
            return new TheoryData<Type>
                {
                    { typeof(int) },
                    { typeof(int[]) },
                    { typeof(string) },
                    { typeof(Guid) },
                    { typeof(List<string>) },
                    { typeof(Dictionary<string, int>) },
                    { typeof(DateTime) },
                    { typeof(bool) },
                    { typeof(Guid[]) }
                };
        }
    }

    [Theory]
    [MemberData(nameof(InvalidTypes))]
    public void CanSerialize_ReturnsFalse_OnInvalidType(Type type)
    {
        // Arrange
        var serializer = CreateSerializer();

        // Act
        var result = serializer.CanSerialize(type);

        // Assert
        Assert.False(result);
    }

    [Theory]
    [MemberData(nameof(InvalidDictionaryKeyTypes))]
    public void CanSerialize_ReturnsFalse_OnInvalidDictionaryKeyType(Type type)
    {
        // Arrange
        var serializer = CreateSerializer();

        // Act
        var result = serializer.CanSerialize(type);

        // Assert
        Assert.False(result);
    }

    [Theory]
    [MemberData(nameof(ValidTypes))]
    public void CanSerialize_ReturnsTrue_OnValidType(Type type)
    {
        // Arrange
        var serializer = CreateSerializer();

        // Act
        var result = serializer.CanSerialize(type);

        // Assert
        Assert.True(result);
    }

    [Fact]
    public void Deserialize_Int()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", 42 }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        Assert.Equal(42, result["key"]);
    }

    [Fact]
    public void Deserialize_Bool()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", true }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        Assert.Equal(true, result["key"]);
    }

    [Fact]
    public void Deserialize_String()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", "hello" }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        Assert.Equal("hello", result["key"]);
    }

    [Fact]
    public void Deserialize_Guid()
    {
        // Arrange
        var serializer = CreateSerializer();
        var guid = Guid.NewGuid();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", guid }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        Assert.Equal(guid, result["key"]);
    }

    [Fact]
    public void Deserialize_DateTime()
    {
        // Arrange
        var serializer = CreateSerializer();
        var dateTime = new DateTime(2007, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", dateTime }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        Assert.IsType<DateTime>(result["key"]);
        Assert.Equal(dateTime, result["key"]);
    }

    [Fact]
    public void Deserialize_Null()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", null }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        Assert.Null(result["key"]);
    }

    [Fact]
    public void Deserialize_Array()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", new int[] { 1, 2, 3 } }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        var array = Assert.IsType<int[]>(result["key"]);
        Assert.Equal(3, array.Length);
        Assert.Equal(1, array[0]);
        Assert.Equal(2, array[1]);
        Assert.Equal(3, array[2]);
    }

    [Fact]
    public void Deserialize_EmptyArray()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", Array.Empty<int>() }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        var array = Assert.IsType<object[]>(result["key"]);
        Assert.Empty(array);
    }

    [Fact]
    public void Deserialize_Dictionary()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", new Dictionary<string, int> { { "key1", 1 }, { "key2", 2 } } }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        var dictionary = Assert.IsType<Dictionary<string, object>>(result["key"]);
        Assert.Equal(2, dictionary.Count);
        Assert.Equal(1, dictionary["key1"]);
        Assert.Equal(2, dictionary["key2"]);
    }

    [Fact]
    public void Deserialize_StringArray()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", new string[] { "foo", "bar" } }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        var array = Assert.IsType<string[]>(result["key"]);
        Assert.Equal(2, array.Length);
        Assert.Equal("foo", array[0]);
        Assert.Equal("bar", array[1]);
    }

    [Fact]
    public void Deserialize_DictionaryWithStringValues()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", new Dictionary<string, string> { { "key1", "value1" }, { "key2", "value2" } } }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        var dictionary = Assert.IsType<Dictionary<string, object>>(result["key"]);
        Assert.Equal(2, dictionary.Count);
        Assert.Equal("value1", dictionary["key1"]);
        Assert.Equal("value2", dictionary["key2"]);
    }

    [Fact]
    public void Deserialize_NestedArrays()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", new object[] { new int[] { 1 }, new int[] { 2, 3, 4 } } }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        var array = Assert.IsType<object[]>(result["key"]);
        Assert.Equal(new int[] { 1 }, array[0]);
        Assert.Equal(new int[] { 2, 3, 4 }, array[1]);
    }

    [Fact]
    public void Deserialize_BoolArray()
    {
        // Arrange
        var serializer = CreateSerializer();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", new bool[] { true, false } }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        var array = Assert.IsType<bool[]>(result["key"]);
        Assert.True(array[0]);
        Assert.False(array[1]);
    }

    [Fact]
    public void Deserialize_DateTimeArray()
    {
        // Arrange
        var serializer = CreateSerializer();
        var dateTime1 = new DateTime(2007, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        var dateTime2 = new DateTime(2008, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", new DateTime[] { dateTime1, dateTime2 } }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        var array = Assert.IsType<DateTime[]>(result["key"]);
        Assert.Equal(dateTime1, array[0]);
        Assert.Equal(dateTime2, array[1]);
    }

    [Fact]
    public void Deserialize_GuidArray()
    {
        // Arrange
        var serializer = CreateSerializer();
        var guid1 = Guid.NewGuid();
        var guid2 = Guid.NewGuid();
        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", new Guid[] { guid1, guid2 } }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        var array = Assert.IsType<Guid[]>(result["key"]);
        Assert.Equal(guid1, array[0]);
        Assert.Equal(guid2, array[1]);
    }

    [Fact]
    public void Deserialize_Enum()
    {
        // Arrange
        var serializer = CreateSerializer();

        var serialized = serializer.SerializeData(new Dictionary<string, object>
        {
            { "key", TestEnum.Value2 }
        });

        // Act
        var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
        var result = serializer.DeserializeData(jsonDocument);

        // Assert
        Assert.Equal(1, result["key"]);
    }

    private class TestItem
    {
        public int DummyInt { get; set; }
    }

    private enum TestEnum
    {
        Value1,
        Value2
    }
}