src/Features/JsonPatch.SystemTextJson/test/IntegrationTests/NestedObjectIntegrationTest.cs - main - githubmirror/aspnetcore

src/Features/JsonPatch.SystemTextJson/test/IntegrationTests/NestedObjectIntegrationTest.cs
347 строк10 KB
Artak
Added System.Text.Json serialization-based JsonPatch implementation (#61313)
22 апр 2025, 01:53
22 апр 2025, 01:53b9e9970
// 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.Dynamic;
using System.Text.Json;
using System.Text.Json.Serialization;
using Microsoft.AspNetCore.Shared;
using Xunit;

namespace Microsoft.AspNetCore.JsonPatch.SystemTextJson.IntegrationTests;

public class NestedObjectIntegrationTest
{
    [Fact]
    public void Replace_DTOWithNullCheck()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObjectWithNullCheck()
        {
            SimpleObjectWithNullCheck = new SimpleObjectWithNullCheck()
            {
                StringProperty = "A"
            }
        };

        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObjectWithNullCheck>();
        patchDocument.Replace(o => o.SimpleObjectWithNullCheck.StringProperty, "B");

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.Equal("B", targetObject.SimpleObjectWithNullCheck.StringProperty);
    }

    [Fact]
    public void ReplaceNestedObject_WithSerialization()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            IntegerValue = 1
        };

        var newNested = new NestedObject() { StringProperty = "B" };
        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Replace(o => o.NestedObject, newNested);

        var serialized = JsonSerializer.Serialize(patchDocument);
        var deserialized = JsonSerializer.Deserialize<JsonPatchDocument<SimpleObjectWithNestedObject>>(serialized);

        // Act
        deserialized.ApplyTo(targetObject);

        // Assert
        Assert.Equal("B", targetObject.NestedObject.StringProperty);
    }

    [Fact]
    public void TestStringProperty_InNestedObject()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            NestedObject = new NestedObject() { StringProperty = "A" }
        };

        var patchDocument = new JsonPatchDocument<NestedObject>();
        patchDocument.Test(o => o.StringProperty, "A");

        // Act
        patchDocument.ApplyTo(targetObject.NestedObject);

        // Assert
        Assert.Equal("A", targetObject.NestedObject.StringProperty);
    }

    [Fact]
    public void TestNestedObject()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            NestedObject = new NestedObject() { StringProperty = "B" }
        };

        var testNested = new NestedObject() { StringProperty = "B" };
        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Test(o => o.NestedObject, testNested);

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.Equal("B", targetObject.NestedObject.StringProperty);
    }

    [Fact]
    public void AddReplaces_ExistingStringProperty()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            SimpleObject = new SimpleObject()
            {
                StringProperty = "A"
            }
        };

        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Add(o => o.SimpleObject.StringProperty, "B");

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.Equal("B", targetObject.SimpleObject.StringProperty);
    }

    [Fact]
    public void RemoveStringProperty()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            SimpleObject = new SimpleObject()
            {
                StringProperty = "A"
            }
        };

        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Remove(o => o.SimpleObject.StringProperty);

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.Null(targetObject.SimpleObject.StringProperty);
    }

    [Fact]
    public void CopyStringProperty_ToAnotherStringProperty()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            SimpleObject = new SimpleObject()
            {
                StringProperty = "A",
                AnotherStringProperty = "B"
            }
        };

        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Copy(o => o.SimpleObject.StringProperty, o => o.SimpleObject.AnotherStringProperty);

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.Equal("A", targetObject.SimpleObject.AnotherStringProperty);
    }

    [Fact]
    public void CopyNullStringProperty_ToAnotherStringProperty()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            SimpleObject = new SimpleObject()
            {
                StringProperty = null,
                AnotherStringProperty = "B"
            }
        };

        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Copy(o => o.SimpleObject.StringProperty, o => o.SimpleObject.AnotherStringProperty);

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.Null(targetObject.SimpleObject.AnotherStringProperty);
    }

    [Fact]
    public void Copy_DeepClonesObject()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            SimpleObject = new SimpleObject()
            {
                StringProperty = "A",
                AnotherStringProperty = "B"
            },
            InheritedObject = new InheritedObject()
            {
                StringProperty = "C",
                AnotherStringProperty = "D"
            }
        };

        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Copy(o => o.InheritedObject, o => o.SimpleObject);

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.Equal("C", targetObject.SimpleObject.StringProperty);
        Assert.Equal("D", targetObject.SimpleObject.AnotherStringProperty);
        Assert.Equal("C", targetObject.InheritedObject.StringProperty);
        Assert.Equal("D", targetObject.InheritedObject.AnotherStringProperty);
        Assert.NotSame(targetObject.SimpleObject.StringProperty, targetObject.InheritedObject.StringProperty);
    }

    [Fact]
    public void Copy_KeepsObjectType()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            SimpleObject = new SimpleObject(),
            InheritedObject = new InheritedObject()
        };

        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Copy(o => o.InheritedObject, o => o.SimpleObject);

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.Equal(typeof(InheritedObject), targetObject.SimpleObject.GetType());
    }

    [Fact]
    public void Copy_BreaksObjectReference()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            SimpleObject = new SimpleObject(),
            InheritedObject = new InheritedObject()
        };

        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Copy(o => o.InheritedObject, o => o.SimpleObject);

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.NotSame(targetObject.SimpleObject, targetObject.InheritedObject);
    }

    [Fact]
    public void MoveIntegerValue_ToAnotherIntegerProperty()
    {
        // Arrange
        var targetObject = new SimpleObjectWithNestedObject()
        {
            SimpleObject = new SimpleObject()
            {
                IntegerValue = 2,
                AnotherIntegerValue = 3
            }
        };

        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Move(o => o.SimpleObject.IntegerValue, o => o.SimpleObject.AnotherIntegerValue);

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.Equal(2, targetObject.SimpleObject.AnotherIntegerValue);
        Assert.Equal(0, targetObject.SimpleObject.IntegerValue);
    }

    [Fact]
    public void Move_KeepsObjectReference()
    {
        // Arrange
        var sDto = new SimpleObject()
        {
            StringProperty = "A",
            AnotherStringProperty = "B"
        };
        var iDto = new InheritedObject()
        {
            StringProperty = "C",
            AnotherStringProperty = "D"
        };
        var targetObject = new SimpleObjectWithNestedObject()
        {
            SimpleObject = sDto,
            InheritedObject = iDto
        };

        var patchDocument = new JsonPatchDocument<SimpleObjectWithNestedObject>();
        patchDocument.Move(o => o.InheritedObject, o => o.SimpleObject);

        // Act
        patchDocument.ApplyTo(targetObject);

        // Assert
        Assert.Equal("C", targetObject.SimpleObject.StringProperty);
        Assert.Equal("D", targetObject.SimpleObject.AnotherStringProperty);
        Assert.Same(iDto, targetObject.SimpleObject);
        Assert.Null(targetObject.InheritedObject);
    }

    private class SimpleObjectWithNullCheck
    {
        private string stringProperty;

        public string StringProperty
        {
            get
            {
                return stringProperty;
            }

            set
            {
                ArgumentNullThrowHelper.ThrowIfNull(value);

                stringProperty = value;
            }
        }
    }

    private class SimpleObjectWithNestedObjectWithNullCheck
    {
        public SimpleObjectWithNullCheck SimpleObjectWithNullCheck { get; set; }

        public SimpleObjectWithNestedObjectWithNullCheck()
        {
            SimpleObjectWithNullCheck = new SimpleObjectWithNullCheck();
        }
    }
}