dev-npgsql/npgsql: Npgsql is the .NET data provider for PostgreSQL.

test/Npgsql.PluginTests/JsonNetTests.cs
263 строки9 KB
Shay Rojansky
Apply file-scoped namespaces for 6.0 (#4298)
28 янв 2022, 15:13
28 янв 2022, 15:132e0ad2d
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Npgsql.Tests;
using NpgsqlTypes;
using NUnit.Framework;
using System;
using System.Text;

// ReSharper disable AccessToModifiedClosure
// ReSharper disable AccessToDisposedClosure

namespace Npgsql.PluginTests;

/// <summary>
/// Tests for the Npgsql.Json.NET mapping plugin
/// </summary>
[NonParallelizable]
[TestFixture(NpgsqlDbType.Jsonb)]
[TestFixture(NpgsqlDbType.Json)]
public class JsonNetTests : TestBase
{
    [Test]
    public void Roundtrip_object()
    {
        var expected = new Foo { Bar = 8 };
        using var conn = OpenConnection();
        using var cmd = new NpgsqlCommand(@"SELECT @p1, @p2", conn);
        cmd.Parameters.Add(new NpgsqlParameter("p1", _npgsqlDbType) { Value = expected });
        cmd.Parameters.Add(new NpgsqlParameter<Foo>
        {
            ParameterName = "p2", NpgsqlDbType = _npgsqlDbType, TypedValue = expected
        });
        using var reader = cmd.ExecuteReader();
        reader.Read();
        Assert.That(reader.GetFieldValue<Foo>(0), Is.EqualTo(expected));
        Assert.That(reader.GetFieldValue<Foo>(1), Is.EqualTo(expected));
    }

    [Test]
    public void Deserialize_failure()
    {
        using var conn = OpenConnection();
        using var cmd = new NpgsqlCommand($@"SELECT '[1, 2, 3]'::{_pgTypeName}", conn);
        using var reader = cmd.ExecuteReader();
        reader.Read();
        // Attempt to deserialize JSON array into object
        Assert.That(() => reader.GetFieldValue<Foo>(0), Throws.TypeOf<JsonSerializationException>());
        // State should still be OK to continue
        var actual = reader.GetFieldValue<JArray>(0);
        Assert.That((int)actual[0], Is.EqualTo(1));
    }

    [Test, IssueLink("https://github.com/npgsql/npgsql/issues/3085")]
    public void Roundtrip_string_types()
    {
        var expected = "{\"p\":1}";
        // If we serialize to JSONB, Postgres will not store the Json.NET formatting, and will add a space after ':'
        var expectedString = _npgsqlDbType.Equals(NpgsqlDbType.Jsonb) ? "{\"p\": 1}"
            : "{\"p\":1}";

        using var conn = OpenConnection();
        using var cmd = new NpgsqlCommand(@"SELECT @p1, @p2, @p3", conn);

        cmd.Parameters.Add(new NpgsqlParameter<string>("p1", _npgsqlDbType) { Value = expected });
        cmd.Parameters.Add(new NpgsqlParameter<char[]>("p2", _npgsqlDbType) { Value = expected.ToCharArray() });
        cmd.Parameters.Add(new NpgsqlParameter<byte[]>("p3", _npgsqlDbType) { Value = Encoding.ASCII.GetBytes(expected) });

        using var reader = cmd.ExecuteReader();
        reader.Read();
        Assert.That(reader.GetFieldValue<string>(0), Is.EqualTo(expectedString));
        Assert.That(reader.GetFieldValue<char[]>(1), Is.EqualTo(expectedString.ToCharArray()));
        Assert.That(reader.GetFieldValue<byte[]>(2), Is.EqualTo(Encoding.ASCII.GetBytes(expectedString)));
    }

    [Test, Ignore("INpgsqlTypeHandler<ArraySegment<char>>.Read currently not yet implemented in TextHandler")]
    public void Roundtrip_ArraySegment()
    {
        var expected = "{\"p\":1}";
        // If we serialize to JSONB, Postgres will not store the Json.NET formatting, and will add a space after ':'
        var expectedString = _npgsqlDbType.Equals(NpgsqlDbType.Jsonb) ? "{\"p\": 1}"
            : "{\"p\":1}";

        using var conn = OpenConnection();
        using var cmd = new NpgsqlCommand(@"SELECT @p1", conn);

        cmd.Parameters.Add(new NpgsqlParameter<ArraySegment<char>>("p1", _npgsqlDbType) { Value = new ArraySegment<char>(expected.ToCharArray()) });

        using var reader = cmd.ExecuteReader();
        reader.Read();
        Assert.That(reader.GetFieldValue<ArraySegment<char>>(0), Is.EqualTo(expectedString));
    }

    class Foo
    {
        public int Bar { get; set; }
        public override bool Equals(object? obj) => (obj as Foo)?.Bar == Bar;
        public override int GetHashCode() => Bar.GetHashCode();
    }

    class Bar
    {
        public int A { get; set; }
    }

    [Test]
    public void Roundtrip_JObject()
    {
        var expected = new JObject { ["Bar"] = 8 };

        using var conn = OpenConnection();
        using var cmd = new NpgsqlCommand(@"SELECT @p", conn);
        cmd.Parameters.Add(new NpgsqlParameter("p", _npgsqlDbType) { Value = expected });
        using var reader = cmd.ExecuteReader();
        reader.Read();
        var actual = reader.GetFieldValue<JObject>(0);
        Assert.That((int)actual["Bar"]!, Is.EqualTo(8));
    }

    [Test]
    public void Roundtrip_JArray()
    {
        var expected = new JArray(new[] { 1, 2, 3 });

        using var conn = OpenConnection();
        using var cmd = new NpgsqlCommand(@"SELECT @p", conn);
        cmd.Parameters.Add(new NpgsqlParameter("p", _npgsqlDbType) { Value = expected });
        using var reader = cmd.ExecuteReader();
        reader.Read();
        var jarray = reader.GetFieldValue<JArray>(0);
        Assert.That(jarray.ToObject<int[]>(), Is.EqualTo(new[] { 1, 2, 3 }));
    }

    [Test]
    public void Clr_type_mapping()
    {
        var expected = new Foo { Bar = 8 };
        using var conn = OpenConnection();
        using var cmd = new NpgsqlCommand(@"SELECT @p", conn);
        conn.TypeMapper.UseJsonNet(new[] { typeof(Foo) });

        cmd.Parameters.AddWithValue("p", expected);
        using var reader = cmd.ExecuteReader();
        reader.Read();
        var actual = reader.GetFieldValue<Foo>(0);
        Assert.That(actual.Bar, Is.EqualTo(8));
    }

    [Test, Ignore("https://github.com/npgsql/npgsql/issues/2568")]
    public void Clr_type_mapping_two_types()
    {
        var value1 = new Foo { Bar = 8 };
        var value2 = new Bar { A = 8 };
        using var conn = OpenConnection();
        using var cmd = new NpgsqlCommand(@"SELECT @p1, @p2", conn);
        conn.TypeMapper.UseJsonNet(new[] { typeof(Foo), typeof(Bar) });

        cmd.Parameters.AddWithValue("p1", value1);
        cmd.Parameters.AddWithValue("p2", value1);
        using var reader = cmd.ExecuteReader();
        reader.Read();
        var actual1 = reader.GetFieldValue<Foo>(0);
        Assert.That(actual1.Bar, Is.EqualTo(8));
        var actual2 = reader.GetFieldValue<Bar>(1);
        Assert.That(actual2.A, Is.EqualTo(8));
    }

    [Test]
    public void Roundtrip_clr_array()
    {
        var expected = new[] { 1, 2, 3 };

        using var conn = OpenConnection();
        conn.TypeMapper.UseJsonNet(new[] { typeof(int[]) });

        using var cmd = new NpgsqlCommand($@"SELECT @p::{_pgTypeName}", conn);
        cmd.Parameters.AddWithValue("p", expected);
        using var reader = cmd.ExecuteReader();
        reader.Read();
        var actual = reader.GetFieldValue<int[]>(0);
        Assert.That(actual, Is.EqualTo(expected));
    }

    class DateWrapper
    {
        public System.DateTime Date;
        public override bool Equals(object? obj) => (obj as DateWrapper)?.Date == Date;
        public override int GetHashCode() => Date.GetHashCode();
    }

    void RoundtripCustomSerializerSettings(bool asJsonb)
    {
        var expected = new DateWrapper() { Date = new System.DateTime(2018, 04, 20) };

        var settings = new JsonSerializerSettings()
        {
            DateFormatString = @"T\he d\t\h o\f MMMM, yyyy"
        };

        // If we serialize to JSONB, Postgres will not store the Json.NET formatting, and will add a space after ':'
        var expectedString = asJsonb ? "{\"Date\": \"The 20th of April, 2018\"}"
            : "{\"Date\":\"The 20th of April, 2018\"}";

        using var conn = OpenConnection();
        if (asJsonb)
        {
            conn.TypeMapper.UseJsonNet(jsonbClrTypes : new[] { typeof(DateWrapper) }, settings : settings);
        }
        else
        {
            conn.TypeMapper.UseJsonNet(jsonClrTypes : new[] { typeof(DateWrapper) }, settings : settings);
        }

        using var cmd = new NpgsqlCommand($@"SELECT @p::{_pgTypeName}, @p::text", conn);
        cmd.Parameters.AddWithValue("p", expected);
        using var reader = cmd.ExecuteReader();
        reader.Read();
        var actual = reader.GetFieldValue<DateWrapper>(0);
        var actualString = reader.GetFieldValue<string>(1);
        Assert.That(actual, Is.EqualTo(expected));
        Assert.That(actualString, Is.EqualTo(expectedString));
    }

    [Test]
    public void Roundtrip_jsonb_custom_serializer_settings() => RoundtripCustomSerializerSettings(asJsonb : true);

    [Test]
    public void Roundtrip_json_custom_serializer_settings() => RoundtripCustomSerializerSettings(asJsonb : false);

    [Test]
    public void Bug3464()
    {
        var expected = new Bug3464Class { SomeString = new string('5', 8174) };
        using var conn = base.OpenConnection();
        using var cmd = new NpgsqlCommand(@"SELECT @p1, @p2", conn);

        conn.TypeMapper.UseJsonNet(new[] { typeof(Bug3464Class) });
        cmd.Parameters.AddWithValue("p1", expected).NpgsqlDbType = _npgsqlDbType;
        cmd.Parameters.AddWithValue("p2", expected).NpgsqlDbType = _npgsqlDbType;

        using var reader = cmd.ExecuteReader();
    }

    public class Bug3464Class
    {
        public string? SomeString { get; set; }
    }

    protected override NpgsqlConnection OpenConnection(string? connectionString = null)
    {
        var conn = base.OpenConnection(connectionString);
        conn.TypeMapper.UseJsonNet();
        return conn;
    }

    readonly NpgsqlDbType _npgsqlDbType;
    readonly string _pgTypeName;

    public JsonNetTests(NpgsqlDbType npgsqlDbType)
    {
        _npgsqlDbType = npgsqlDbType;
        _pgTypeName = npgsqlDbType.ToString().ToLower();
    }
}