119 lines
4.3 KiB
C#
119 lines
4.3 KiB
C#
using NUnit.Framework;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using Sarand.Net.Standard.Base.Bus;
|
|
using Sarand.Net.Standard.Base.Helpers;
|
|
using Sarand.Net.Standard.Base.Utils;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Sacs.UnitTests.Net.Standard.Base.Utils
|
|
{
|
|
[TestFixture]
|
|
public class NewtonsoftJsonUtil_Tester
|
|
{
|
|
// --- Definitions ---
|
|
|
|
private class JsonData
|
|
{
|
|
public string Name { get; set; }
|
|
public int Count { get; set; }
|
|
public string Optional { get; set; }
|
|
public List<string> Values { get; set; } = new List<string> { "constructor value" };
|
|
}
|
|
|
|
// --- Serialization ---
|
|
|
|
[Test]
|
|
public void SerializeObject_HandlesObjectsArraysNullsAndSettings()
|
|
{
|
|
JsonData data = new JsonData { Name = "alpha", Count = 3, Optional = null };
|
|
JsonSerializerSettings settings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore };
|
|
|
|
string objectJson = NewtonsoftJsonUtil.SerializeObject(data, settings);
|
|
string arrayJson = NewtonsoftJsonUtil.SerializeObject(new[] { 1, 2, 3 });
|
|
|
|
Assert.That(objectJson, Does.Contain("\"Name\":\"alpha\""));
|
|
Assert.That(objectJson.Contains("Optional"), Is.False);
|
|
Assert.That(arrayJson, Is.EqualTo("[1,2,3]"));
|
|
Assert.That(NewtonsoftJsonUtil.SerializeObject(null), Is.EqualTo("null"));
|
|
}
|
|
|
|
[Test]
|
|
public void SysIdJsonConverter_RoundTripsValidAndInvalidValues()
|
|
{
|
|
string validJson = JsonConvert.SerializeObject(new SysId(42));
|
|
string invalidJson = JsonConvert.SerializeObject(new SysId());
|
|
|
|
SysId validId = JsonConvert.DeserializeObject<SysId>(validJson);
|
|
SysId invalidId = JsonConvert.DeserializeObject<SysId>(invalidJson);
|
|
|
|
Assert.That(validJson, Is.EqualTo("42"));
|
|
Assert.That(invalidJson, Is.EqualTo("0"));
|
|
Assert.That(validId.ToInt(), Is.EqualTo(42));
|
|
Assert.That(SysId.IsValid(invalidId), Is.False);
|
|
Assert.That(SysId.IsValid(JsonConvert.DeserializeObject<SysId>("null")), Is.False);
|
|
}
|
|
|
|
// --- Parsing ---
|
|
|
|
[Test]
|
|
public void ParseJsonMethods_ParseTokensObjectsAndArrays()
|
|
{
|
|
JToken token = NewtonsoftJsonUtil.ParseJsonToken("123");
|
|
JObject jsonObject = NewtonsoftJsonUtil.ParseJsonObject("{\"name\":\"alpha\",\"nested\":{\"enabled\":true}}");
|
|
JArray jsonArray = NewtonsoftJsonUtil.ParseJsonArray("[1,2,3]");
|
|
|
|
Assert.That(token.Value<int>(), Is.EqualTo(123));
|
|
Assert.That(jsonObject["name"].Value<string>(), Is.EqualTo("alpha"));
|
|
Assert.That(jsonObject["nested"]["enabled"].Value<bool>(), Is.True);
|
|
Assert.That(jsonArray.ToObject<int[]>(), Is.EqualTo(new[] { 1, 2, 3 }));
|
|
}
|
|
|
|
[Test]
|
|
public void ParseJsonMethods_ReportInvalidInputWithoutThrowing()
|
|
{
|
|
Assert.That(NewtonsoftJsonUtil.ParseJsonToken("{", out Exception tokenException), Is.Null);
|
|
Assert.That(tokenException, Is.Not.Null);
|
|
Assert.That(NewtonsoftJsonUtil.ParseJsonObject("[]", out Exception objectException), Is.Null);
|
|
Assert.That(objectException, Is.Not.Null);
|
|
Assert.That(NewtonsoftJsonUtil.ParseJsonArray("{}", out Exception arrayException), Is.Null);
|
|
Assert.That(arrayException, Is.Not.Null);
|
|
Assert.Throws<JsonReaderException>(() => NewtonsoftJsonUtil.ParseJsonToken("{"));
|
|
}
|
|
|
|
[Test]
|
|
public void DeserializeJsonObject_ProvidesDynamicPropertyAccess()
|
|
{
|
|
dynamic data = SacsJsonHelper.DeserializeJsonObject("{\"name\":\"alpha\",\"count\":3,\"items\":[\"a\",\"b\"]}");
|
|
|
|
Assert.That((string)data.name, Is.EqualTo("alpha"));
|
|
Assert.That((int)data.count, Is.EqualTo(3));
|
|
Assert.That((string)data.items[1], Is.EqualTo("b"));
|
|
Assert.That((object)SacsJsonHelper.DeserializeJsonObject("null"), Is.Null);
|
|
}
|
|
|
|
// --- Deep Copy ---
|
|
|
|
[Test]
|
|
public void DeepCopy_CreatesIndependentNestedCollectionsAndReplacesConstructorValues()
|
|
{
|
|
JsonData source = new JsonData { Name = "source", Count = 2 };
|
|
source.Values.Clear();
|
|
source.Values.AddRange(new[] { "one", "two" });
|
|
|
|
JsonData copy = SerializableUtil.DeepCopy(source);
|
|
copy.Values.Add("copy only");
|
|
|
|
Assert.That(copy, Is.Not.SameAs(source));
|
|
Assert.That(copy.Values, Is.Not.SameAs(source.Values));
|
|
Assert.That(source.Values, Is.EqualTo(new[] { "one", "two" }));
|
|
Assert.That(copy.Values, Is.EqualTo(new[] { "one", "two", "copy only" }));
|
|
Assert.That(SerializableUtil.DeepCopy<JsonData>(null), Is.Null);
|
|
Assert.That(SerializableUtil.ToJson<JsonData>(null), Is.Empty);
|
|
}
|
|
|
|
// --- The End ---
|
|
}
|
|
}
|