Fixes for json.

src/Squidex.Domain.Apps.Events/SquidexHeaderExtensions.cs

@@ -19,7 +19,7 @@ namespace Squidex.Domain.Apps.Events
 
         public static Envelope<T> SetAppId<T>(this Envelope<T> envelope, Guid value) where T : class
         {
-            envelope.Headers.Add(SquidexHeaders.AppId, value);
+            envelope.Headers.Add(SquidexHeaders.AppId, value.ToString());
 
             return envelope;
         }

src/Squidex.Infrastructure/EventSourcing/EnvelopeExtensions.cs

@@ -17,7 +17,7 @@ namespace Squidex.Infrastructure.EventSourcing
     {
         public static string EventPosition(this EnvelopeHeaders headers)
         {
-            return headers[CommonHeaders.EventNumber].ToString();
+            return headers.GetString(CommonHeaders.EventNumber);
         }
 
         public static Envelope<T> SetEventPosition<T>(this Envelope<T> envelope, string value) where T : class
@@ -29,7 +29,7 @@ namespace Squidex.Infrastructure.EventSourcing
 
         public static long EventStreamNumber(this EnvelopeHeaders headers)
         {
-            return headers.GetInt64(CommonHeaders.EventStreamNumber);
+            return headers.GetLong(CommonHeaders.EventStreamNumber);
         }
 
         public static Envelope<T> SetEventStreamNumber<T>(this Envelope<T> envelope, long value) where T : class
@@ -46,7 +46,7 @@ namespace Squidex.Infrastructure.EventSourcing
 
         public static Envelope<T> SetCommitId<T>(this Envelope<T> envelope, Guid value) where T : class
         {
-            envelope.Headers.Add(CommonHeaders.CommitId, value);
+            envelope.Headers.Add(CommonHeaders.CommitId, value.ToString());
 
             return envelope;
         }
@@ -58,7 +58,7 @@ namespace Squidex.Infrastructure.EventSourcing
 
         public static Envelope<T> SetAggregateId<T>(this Envelope<T> envelope, Guid value) where T : class
         {
-            envelope.Headers.Add(CommonHeaders.AggregateId, value);
+            envelope.Headers.Add(CommonHeaders.AggregateId, value.ToString());
 
             return envelope;
         }
@@ -70,7 +70,7 @@ namespace Squidex.Infrastructure.EventSourcing
 
         public static Envelope<T> SetEventId<T>(this Envelope<T> envelope, Guid value) where T : class
         {
-            envelope.Headers.Add(CommonHeaders.EventId, value);
+            envelope.Headers.Add(CommonHeaders.EventId, value.ToString());
 
             return envelope;
         }
@@ -82,30 +82,62 @@ namespace Squidex.Infrastructure.EventSourcing
 
         public static Envelope<T> SetTimestamp<T>(this Envelope<T> envelope, Instant value) where T : class
         {
-            envelope.Headers.Add(CommonHeaders.Timestamp, value);
+            envelope.Headers.Add(CommonHeaders.Timestamp, value.ToString());
 
             return envelope;
         }
 
-        public static long GetInt64(this JsonObject obj, string key)
+        public static long GetLong(this JsonObject obj, string key)
         {
-            var value = obj[key];
+            if (obj.TryGetValue(key, out var v))
-
+            {
-            return value is JsonScalar<double> s ? (long)s.Value : long.Parse(value.ToString(), CultureInfo.InvariantCulture);
+                if (v is JsonScalar<double> number)
+                {
+                    return (long)number.Value;
+                }
+                else if (v.Type == JsonValueType.String && double.TryParse(v.ToString(), NumberStyles.Any, CultureInfo.InvariantCulture, out var result))
+                {
+                    return (long)result;
+                }
+            }
+
+            return 0;
         }
 
         public static Guid GetGuid(this JsonObject obj, string key)
         {
-            var value = obj[key];
+            if (obj.TryGetValue(key, out var v))
-
+            {
-            return Guid.Parse(value.ToString());
+                if (v.Type == JsonValueType.String && Guid.TryParse(v.ToString(), out var guid))
+                {
+                    return guid;
+                }
+            }
+
+            return default(Guid);
         }
 
         public static Instant GetInstant(this JsonObject obj, string key)
         {
-            var value = obj[key];
+            if (obj.TryGetValue(key, out var v))
+            {
+                if (v.Type == JsonValueType.String && InstantPattern.General.Parse(v.ToString()).TryGetValue(default(Instant), out var instant))
+                {
+                    return instant;
+                }
+            }
+
+            return default(Instant);
+        }
+
+        public static string GetString(this JsonObject obj, string key)
+        {
+            if (obj.TryGetValue(key, out var v))
+            {
+                return v.ToString();
+            }
 
-            return InstantPattern.General.Parse(value.ToString()).Value;
+            return string.Empty;
         }
     }
 }

src/Squidex.Infrastructure/Json/Newtonsoft/EnvelopeHeadersConverter.cs

@@ -0,0 +1,34 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschraenkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using System;
+using Newtonsoft.Json;
+using Squidex.Infrastructure.EventSourcing;
+using Squidex.Infrastructure.Json.Objects;
+
+namespace Squidex.Infrastructure.Json.Newtonsoft
+{
+    public sealed class EnvelopeHeadersConverter : JsonValueConverter
+    {
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var result = base.ReadJson(reader, objectType, existingValue, serializer);
+
+            if (result is JsonObject obj)
+            {
+                return new EnvelopeHeaders(obj);
+            }
+
+            return result;
+        }
+
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(EnvelopeHeaders);
+        }
+    }
+}

src/Squidex.Infrastructure/Json/Newtonsoft/JsonValueConverter.cs

@@ -8,13 +8,14 @@
 using System;
 using System.Globalization;
 using Newtonsoft.Json;
+using Squidex.Infrastructure.EventSourcing;
 using Squidex.Infrastructure.Json.Objects;
 
 #pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
 
 namespace Squidex.Infrastructure.Json.Newtonsoft
 {
-    public sealed class JsonValueConverter : JsonConverter
+    public class JsonValueConverter : JsonConverter
     {
         public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
         {
@@ -161,7 +162,7 @@ namespace Squidex.Infrastructure.Json.Newtonsoft
 
         public override bool CanConvert(Type objectType)
         {
-            return typeof(IJsonValue).IsAssignableFrom(objectType);
+            return objectType != typeof(EnvelopeHeaders) && typeof(IJsonValue).IsAssignableFrom(objectType);
         }
     }
 }

src/Squidex.Infrastructure/Json/Objects/JsonArray.cs

@@ -6,7 +6,6 @@
 // ==========================================================================
 
 using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 
@@ -23,28 +22,19 @@ namespace Squidex.Infrastructure.Json.Objects
         {
         }
 
-        public JsonArray(IList<IJsonValue> values)
+        internal JsonArray(params object[] values)
-            : base(values)
-        {
-        }
-
-        public JsonArray(params object[] values)
             : base(values?.Select(JsonValue.Create).ToList())
         {
         }
 
         protected override void InsertItem(int index, IJsonValue item)
         {
-            Guard.NotNull(item, nameof(item));
+            base.InsertItem(index, item ?? JsonValue.Null);
-
-            base.InsertItem(index, item);
         }
 
         protected override void SetItem(int index, IJsonValue item)
         {
-            Guard.NotNull(item, nameof(item));
+            base.SetItem(index, item ?? JsonValue.Null);
-
-            base.SetItem(index, item);
         }
 
         public override bool Equals(object obj)
@@ -77,7 +67,7 @@ namespace Squidex.Infrastructure.Json.Objects
 
         public override int GetHashCode()
         {
-            var hashCode = 0;
+            var hashCode = 17;
 
             for (var i = 0; i < Count; i++)
             {
@@ -94,7 +84,7 @@ namespace Squidex.Infrastructure.Json.Objects
 
         public override string ToString()
         {
-            return $"[{string.Join(", ", this)}]";
+            return $"[{string.Join(", ", this.Select(x => x.ToJsonString()))}]";
         }
     }
 }

src/Squidex.Infrastructure/Json/Objects/JsonObject.cs

@@ -25,9 +25,8 @@ namespace Squidex.Infrastructure.Json.Objects
             set
             {
                 Guard.NotNullOrEmpty(key, nameof(key));
-                Guard.NotNull(value, nameof(value));
 
-                inner[key] = value;
+                inner[key] = value ?? JsonValue.Null;
             }
         }
 
@@ -68,10 +67,7 @@ namespace Squidex.Infrastructure.Json.Objects
 
         public JsonObject Add(string key, IJsonValue value)
         {
-            Guard.NotNullOrEmpty(key, nameof(key));
+            inner[key] = value ?? JsonValue.Null;
-            Guard.NotNull(value, nameof(value));
-
-            inner[key] = value;
 
             return this;
         }

src/Squidex.Infrastructure/Json/Objects/JsonScalar.cs

@@ -47,14 +47,24 @@ namespace Squidex.Infrastructure.Json.Objects
             return value.GetHashCode();
         }
 
-        public string ToJsonString()
+        public override string ToString()
         {
-            return Type == JsonValueType.String ? $"\"{value}\"" : ToString();
+            if (Type == JsonValueType.Boolean)
+            {
+                return Equals(Value, true) ? "true" : "false";
+            }
+
+            return Value.ToString();
         }
 
-        public override string ToString()
+        public string ToJsonString()
         {
-            return value.ToString();
+            if (Type == JsonValueType.String)
+            {
+                return $"\"{value}\"";
+            }
+
+            return ToString();
         }
     }
 }

src/Squidex.Infrastructure/Json/Objects/JsonValue.cs

@@ -8,16 +8,20 @@
 using System;
 using NodaTime;
 
+#pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
+
 namespace Squidex.Infrastructure.Json.Objects
 {
     public static class JsonValue
     {
-        public static readonly JsonScalar<string> Empty = new JsonScalar<string>(JsonValueType.String, string.Empty);
+        public static readonly IJsonValue Empty = new JsonScalar<string>(JsonValueType.String, string.Empty);
+
+        public static readonly IJsonValue True = new JsonScalar<bool>(JsonValueType.Boolean, true);
+        public static readonly IJsonValue False = new JsonScalar<bool>(JsonValueType.Boolean, false);
 
-        public static readonly JsonScalar<bool> True = new JsonScalar<bool>(JsonValueType.Boolean, true);
+        public static readonly IJsonValue Null = JsonNull.Null;
-        public static readonly JsonScalar<bool> False = new JsonScalar<bool>(JsonValueType.Boolean, false);
 
-        public static readonly JsonNull Null = JsonNull.Null;
+        public static readonly IJsonValue Zero = new JsonScalar<double>(JsonValueType.Number, 0);
 
         public static JsonArray Array()
         {
@@ -76,6 +80,11 @@ namespace Squidex.Infrastructure.Json.Objects
         {
             Guard.ValidNumber(value, nameof(value));
 
+            if (value == 0)
+            {
+                return Zero;
+            }
+
             return new JsonScalar<double>(JsonValueType.Number, value);
         }
 

src/Squidex/Config/Domain/SerializationServices.cs

@@ -49,6 +49,7 @@ namespace Squidex.Config.Domain
                 new AppContributorsConverter(),
                 new AppPatternsConverter(),
                 new ClaimsPrincipalConverter(),
+                new EnvelopeHeadersConverter(),
                 new InstantConverter(),
                 new JsonValueConverter(),
                 new LanguageConverter(),

tests/RunCoverage.ps1

@@ -76,6 +76,6 @@ if ($all -Or $web) {
 	-oldStyle
 }
 
-&"$folderHome\.nuget\packages\ReportGenerator\4.0.4\tools\ReportGenerator.exe" `
+&"$folderHome\.nuget\packages\ReportGenerator\4.0.4\tools\net47\ReportGenerator.exe" `
 -reports:"$folderWorking\$folderReports\*.xml" `
 -targetdir:"$folderWorking\$folderReports\Output"

tests/Squidex.Domain.Apps.Core.Tests/Model/PartitioningTests.cs

@@ -68,37 +68,18 @@ namespace Squidex.Domain.Apps.Core.Model
         [Fact]
         public void Should_make_correct_equal_comparisons()
         {
-            var partitioning1a = new Partitioning("partitioning1");
+            var partitioning1_a = new Partitioning("partitioning1");
-            var partitioning1b = new Partitioning("partitioning1");
+            var partitioning1_b = new Partitioning("partitioning1");
-            var partitioning2a = new Partitioning("partitioning2");
 
-            Assert.True(partitioning1a.Equals(partitioning1b));
+            var partitioning2 = new Partitioning("partitioning2");
 
-            Assert.False(partitioning1a.Equals(partitioning2a));
+            Assert.Equal(partitioning1_a, partitioning1_b);
-        }
+            Assert.Equal(partitioning1_a.GetHashCode(), partitioning1_b.GetHashCode());
-
+            Assert.True(partitioning1_a.Equals((object)partitioning1_b));
-        [Fact]
-        public void Should_make_correct_object_equal_comparisons()
-        {
-            object partitioning1a = new Partitioning("partitioning1");
-            object partitioning1b = new Partitioning("partitioning1");
-            object partitioning2a = new Partitioning("partitioning2");
-
-            Assert.True(partitioning1a.Equals(partitioning1b));
-
-            Assert.False(partitioning1a.Equals(partitioning2a));
-        }
-
-        [Fact]
-        public void Should_provide_correct_hash_codes()
-        {
-            var partitioning1a = new Partitioning("partitioning1");
-            var partitioning1b = new Partitioning("partitioning1");
-            var partitioning2a = new Partitioning("partitioning2");
-
-            Assert.Equal(partitioning1a.GetHashCode(), partitioning1b.GetHashCode());
 
-            Assert.NotEqual(partitioning1a.GetHashCode(), partitioning2a.GetHashCode());
+            Assert.NotEqual(partitioning1_a, partitioning2);
+            Assert.NotEqual(partitioning1_a.GetHashCode(), partitioning2.GetHashCode());
+            Assert.False(partitioning1_a.Equals((object)partitioning2));
         }
     }
 }

tests/Squidex.Domain.Apps.Core.Tests/TestUtils.cs

@@ -40,6 +40,7 @@ namespace Squidex.Domain.Apps.Core
                     new AppContributorsConverter(),
                     new AppPatternsConverter(),
                     new ClaimsPrincipalConverter(),
+                    new EnvelopeHeadersConverter(),
                     new InstantConverter(),
                     new JsonValueConverter(),
                     new LanguageConverter(),

tests/Squidex.Infrastructure.Tests/EventSourcing/EnvelopeExtensionsTests.cs

@@ -18,7 +18,7 @@ namespace Squidex.Infrastructure.EventSourcing
         [Fact]
         public void Should_set_and_get_timestamp()
         {
-            var timestamp = SystemClock.Instance.GetCurrentInstant();
+            var timestamp = Instant.FromUnixTimeSeconds(SystemClock.Instance.GetCurrentInstant().ToUnixTimeSeconds());
 
             sut.SetTimestamp(timestamp);
 
@@ -78,7 +78,7 @@ namespace Squidex.Infrastructure.EventSourcing
             sut.SetEventStreamNumber(eventStreamNumber);
 
             Assert.Equal(eventStreamNumber, sut.Headers.EventStreamNumber());
-            Assert.Equal(eventStreamNumber, sut.Headers.GetInt64("EventStreamNumber"));
+            Assert.Equal(eventStreamNumber, sut.Headers.GetLong("EventStreamNumber"));
         }
     }
 }

tests/Squidex.Infrastructure.Tests/EventSourcing/Grains/EventConsumerGrainTests.cs

@@ -64,7 +64,10 @@ namespace Squidex.Infrastructure.EventSourcing.Grains
             consumerName = eventConsumer.GetType().Name;
 
             A.CallTo(() => store.WithSnapshots(A<Type>.Ignored, consumerName, A<Func<EventConsumerState, Task>>.Ignored))
-                .Invokes(new Action<Type, string, Func<EventConsumerState, Task>>((t, key, a) => apply = a))
+                .Invokes(new Action<Type, string, Func<EventConsumerState, Task>>((t, key, a) =>
+                {
+                    apply = a;
+                }))
                 .Returns(persistence);
 
             A.CallTo(() => eventStore.CreateSubscription(A<IEventSubscriber>.Ignored, A<string>.Ignored, A<string>.Ignored))
@@ -79,7 +82,8 @@ namespace Squidex.Infrastructure.EventSourcing.Grains
             A.CallTo(() => persistence.WriteSnapshotAsync(A<EventConsumerState>.Ignored))
                 .Invokes(new Action<EventConsumerState>(s => state = s));
 
-            A.CallTo(() => formatter.Parse(eventData, true, null)).Returns(envelope);
+            A.CallTo(() => formatter.Parse(eventData, true, null))
+                .Returns(envelope);
 
             sut = new MyEventConsumerGrain(
                 x => eventConsumer,

tests/Squidex.Infrastructure.Tests/Json/Objects/JsonObjectTests.cs

@@ -0,0 +1,321 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschraenkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Squidex.Infrastructure.Json.Objects
+{
+    public class JsonObjectTests
+    {
+        [Fact]
+        public void Should_make_correct_object_equal_comparisons()
+        {
+            var obj_count1_key1_val1_a = JsonValue.Object().Add("key1", 1);
+            var obj_count1_key1_val1_b = JsonValue.Object().Add("key1", 1);
+
+            var obj_count1_key1_val2 = JsonValue.Object().Add("key1", 2);
+            var obj_count1_key2_val1 = JsonValue.Object().Add("key2", 1);
+            var obj_count2_key1_val1 = JsonValue.Object().Add("key1", 1).Add("key2", 2);
+
+            var number = JsonValue.Create(1);
+
+            Assert.Equal(obj_count1_key1_val1_a, obj_count1_key1_val1_b);
+            Assert.Equal(obj_count1_key1_val1_a.GetHashCode(), obj_count1_key1_val1_b.GetHashCode());
+            Assert.True(obj_count1_key1_val1_a.Equals((object)obj_count1_key1_val1_b));
+
+            Assert.NotEqual(obj_count1_key1_val1_a, obj_count1_key1_val2);
+            Assert.NotEqual(obj_count1_key1_val1_a.GetHashCode(), obj_count1_key1_val2.GetHashCode());
+            Assert.False(obj_count1_key1_val1_a.Equals((object)obj_count1_key1_val2));
+
+            Assert.NotEqual(obj_count1_key1_val1_a, obj_count1_key2_val1);
+            Assert.NotEqual(obj_count1_key1_val1_a.GetHashCode(), obj_count1_key2_val1.GetHashCode());
+            Assert.False(obj_count1_key1_val1_a.Equals((object)obj_count1_key2_val1));
+
+            Assert.NotEqual(obj_count1_key1_val1_a, obj_count2_key1_val1);
+            Assert.NotEqual(obj_count1_key1_val1_a.GetHashCode(), obj_count2_key1_val1.GetHashCode());
+            Assert.False(obj_count1_key1_val1_a.Equals((object)obj_count2_key1_val1));
+
+            Assert.NotEqual(obj_count1_key1_val1_a, number);
+            Assert.NotEqual(obj_count1_key1_val1_a.GetHashCode(), number.GetHashCode());
+            Assert.False(obj_count1_key1_val1_a.Equals((object)number));
+        }
+
+        [Fact]
+        public void Should_make_correct_array_equal_comparisons()
+        {
+            var array_count1_val1_a = JsonValue.Array(1);
+            var array_count1_val1_b = JsonValue.Array(1);
+
+            var array_count1_val2 = JsonValue.Array(2);
+            var array_count2_val1 = JsonValue.Array(1, 2);
+
+            var number = JsonValue.Create(1);
+
+            Assert.Equal(array_count1_val1_a, array_count1_val1_b);
+            Assert.Equal(array_count1_val1_a.GetHashCode(), array_count1_val1_b.GetHashCode());
+            Assert.True(array_count1_val1_a.Equals((object)array_count1_val1_b));
+
+            Assert.NotEqual(array_count1_val1_a, array_count1_val2);
+            Assert.NotEqual(array_count1_val1_a.GetHashCode(), array_count1_val2.GetHashCode());
+            Assert.False(array_count1_val1_a.Equals((object)array_count1_val2));
+
+            Assert.NotEqual(array_count1_val1_a, array_count2_val1);
+            Assert.NotEqual(array_count1_val1_a.GetHashCode(), array_count2_val1.GetHashCode());
+            Assert.False(array_count1_val1_a.Equals((object)array_count2_val1));
+
+            Assert.NotEqual(array_count1_val1_a, number);
+            Assert.NotEqual(array_count1_val1_a.GetHashCode(), number.GetHashCode());
+            Assert.False(array_count1_val1_a.Equals((object)number));
+        }
+
+        [Fact]
+        public void Should_make_correct_array_scalar_comparisons()
+        {
+            var number_val1_a = JsonValue.Create(1);
+            var number_val1_b = JsonValue.Create(1);
+
+            var number_val2 = JsonValue.Create(2);
+
+            var boolean = JsonValue.True;
+
+            Assert.Equal(number_val1_a, number_val1_b);
+            Assert.Equal(number_val1_a.GetHashCode(), number_val1_b.GetHashCode());
+            Assert.True(number_val1_a.Equals((object)number_val1_b));
+
+            Assert.NotEqual(number_val1_a, number_val2);
+            Assert.NotEqual(number_val1_a.GetHashCode(), number_val2.GetHashCode());
+            Assert.False(number_val1_a.Equals((object)number_val2));
+
+            Assert.NotEqual(number_val1_a, boolean);
+            Assert.NotEqual(number_val1_a.GetHashCode(), boolean.GetHashCode());
+            Assert.False(number_val1_a.Equals((object)boolean));
+        }
+
+        [Fact]
+        public void Should_make_correct_null_comparisons()
+        {
+            var null_a = JsonValue.Null;
+            var null_b = JsonValue.Null;
+
+            var boolean = JsonValue.True;
+
+            Assert.Equal(null_a, null_b);
+            Assert.Equal(null_a.GetHashCode(), null_b.GetHashCode());
+            Assert.True(null_a.Equals((object)null_b));
+
+            Assert.NotEqual(null_a, boolean);
+            Assert.NotEqual(null_a.GetHashCode(), boolean.GetHashCode());
+            Assert.False(null_a.Equals((object)boolean));
+        }
+
+        [Fact]
+        public void Should_cache_null()
+        {
+            Assert.Same(JsonValue.Null, JsonValue.Create((string)null));
+        }
+
+        [Fact]
+        public void Should_cache_true()
+        {
+            Assert.Same(JsonValue.True, JsonValue.Create(true));
+        }
+
+        [Fact]
+        public void Should_cache_false()
+        {
+            Assert.Same(JsonValue.False, JsonValue.Create(false));
+        }
+
+        [Fact]
+        public void Should_cache_empty()
+        {
+            Assert.Same(JsonValue.Empty, JsonValue.Create(string.Empty));
+        }
+
+        [Fact]
+        public void Should_cache_zero()
+        {
+            Assert.Same(JsonValue.Zero, JsonValue.Create(0));
+        }
+
+        [Fact]
+        public void Should_create_array()
+        {
+            var json = JsonValue.Array(1, "2");
+
+            Assert.Equal("[1, \"2\"]", json.ToJsonString());
+            Assert.Equal("[1, \"2\"]", json.ToString());
+        }
+
+        [Fact]
+        public void Should_create_object()
+        {
+            var json = JsonValue.Object().Add("key1", 1).Add("key2", "2");
+
+            Assert.Equal("{\"key1\":1, \"key2\":\"2\"}", json.ToJsonString());
+            Assert.Equal("{\"key1\":1, \"key2\":\"2\"}", json.ToString());
+        }
+
+        [Fact]
+        public void Should_create_number()
+        {
+            var json = JsonValue.Create(123);
+
+            Assert.Equal("123", json.ToJsonString());
+            Assert.Equal("123", json.ToString());
+        }
+
+        [Fact]
+        public void Should_create_boolean_true()
+        {
+            var json = JsonValue.Create(true);
+
+            Assert.Equal("true", json.ToJsonString());
+            Assert.Equal("true", json.ToString());
+        }
+
+        [Fact]
+        public void Should_create_boolean_false()
+        {
+            var json = JsonValue.Create(false);
+
+            Assert.Equal("false", json.ToJsonString());
+            Assert.Equal("false", json.ToString());
+        }
+
+        [Fact]
+        public void Should_create_string()
+        {
+            var json = JsonValue.Create("hi");
+
+            Assert.Equal("\"hi\"", json.ToJsonString());
+            Assert.Equal("hi", json.ToString());
+        }
+
+        [Fact]
+        public void Should_create_null()
+        {
+            var json = JsonValue.Create((object)null);
+
+            Assert.Equal("null", json.ToJsonString());
+            Assert.Equal("null", json.ToString());
+        }
+
+        [Fact]
+        public void Should_create_arrays_in_different_ways()
+        {
+            var numbers = new[]
+            {
+                JsonValue.Array(1.0f, 2.0f),
+                JsonValue.Array(JsonValue.Create(1.0f), JsonValue.Create(2.0f))
+            };
+
+            Assert.Single(numbers.Distinct());
+            Assert.Single(numbers.Select(x => x.GetHashCode()).Distinct());
+        }
+
+        [Fact]
+        public void Should_create_number_from_types()
+        {
+            var numbers = new[]
+            {
+                JsonValue.Create(1.0f),
+                JsonValue.Create(1.0),
+                JsonValue.Create(1L),
+                JsonValue.Create(1)
+            };
+
+            Assert.Single(numbers.Distinct());
+            Assert.Single(numbers.Select(x => x.GetHashCode()).Distinct());
+        }
+
+        [Fact]
+        public void Should_create_null_when_adding_null_to_array()
+        {
+            var array = JsonValue.Array();
+
+            array.Add(null);
+
+            Assert.Same(JsonValue.Null, array[0]);
+        }
+
+        [Fact]
+        public void Should_create_null_when_replacing_to_null_in_array()
+        {
+            var array = JsonValue.Array(1);
+
+            array[0] = null;
+
+            Assert.Same(JsonValue.Null, array[0]);
+        }
+
+        [Fact]
+        public void Should_create_null_when_adding_null_to_object()
+        {
+            var obj = JsonValue.Object();
+
+            obj.Add("key", null);
+
+            Assert.Same(JsonValue.Null, obj["key"]);
+        }
+
+        [Fact]
+        public void Should_create_null_when_replacing_to_null_object()
+        {
+            var obj = JsonValue.Object();
+
+            obj["key"] = null;
+
+            Assert.Same(JsonValue.Null, obj["key"]);
+        }
+
+        [Fact]
+        public void Should_remove_value_from_object()
+        {
+            var obj = JsonValue.Object().Add("key", 1);
+
+            obj.Remove("key");
+
+            Assert.False(obj.TryGetValue("key", out _));
+            Assert.False(obj.ContainsKey("key"));
+        }
+
+        [Fact]
+        public void Should_clear_values_from_object()
+        {
+            var obj = JsonValue.Object().Add("key", 1);
+
+            obj.Clear();
+
+            Assert.False(obj.TryGetValue("key", out _));
+            Assert.False(obj.ContainsKey("key"));
+        }
+
+        [Fact]
+        public void Should_provide_collection_values_from_object()
+        {
+            var obj = JsonValue.Object().Add("11", "44").Add("22", "88");
+
+            var kvps = new[]
+            {
+                new KeyValuePair<string, IJsonValue>("11", JsonValue.Create("44")),
+                new KeyValuePair<string, IJsonValue>("22", JsonValue.Create("88"))
+            };
+
+            Assert.Equal(2, obj.Count);
+
+            Assert.Equal(new[] { "11", "22" }, obj.Keys);
+            Assert.Equal(new[] { "44", "88" }, obj.Values.Select(x => x.ToString()));
+
+            Assert.Equal(kvps, obj.ToArray());
+            Assert.Equal(kvps, ((IEnumerable)obj).OfType<KeyValuePair<string, IJsonValue>>().ToArray());
+        }
+    }
+}

tests/Squidex.Infrastructure.Tests/NamedIdTests.cs

@@ -40,49 +40,23 @@ namespace Squidex.Infrastructure
             var id1 = Guid.NewGuid();
             var id2 = Guid.NewGuid();
 
-            var token1a = NamedId.Of(id1, "my-name1");
+            var named_id1_name1_a = NamedId.Of(id1, "name1");
-            var token1b = NamedId.Of(id1, "my-name1");
+            var named_id1_name1_b = NamedId.Of(id1, "name1");
-            var token1c = NamedId.Of(id1, "my-name2");
-            var token2a = NamedId.Of(id2, "my-name1");
 
-            Assert.True(token1a.Equals(token1b));
+            var named_id2_name1 = NamedId.Of(id2, "name1");
+            var named_id1_name2 = NamedId.Of(id1, "name2");
 
-            Assert.False(token1a.Equals(token2a));
+            Assert.Equal(named_id1_name1_a, named_id1_name1_b);
-            Assert.False(token1a.Equals(token1c));
+            Assert.Equal(named_id1_name1_a.GetHashCode(), named_id1_name1_b.GetHashCode());
-        }
+            Assert.True(named_id1_name1_a.Equals((object)named_id1_name1_b));
-
-        [Fact]
-        public void Should_make_correct_object_equal_comparisons()
-        {
-            var id1 = Guid.NewGuid();
-            var id2 = Guid.NewGuid();
-
-            object token1a = NamedId.Of(id1, "my-name1");
-            object token1b = NamedId.Of(id1, "my-name1");
-            object token1c = NamedId.Of(id1, "my-name2");
-            object token2a = NamedId.Of(id2, "my-name1");
-
-            Assert.True(token1a.Equals(token1b));
-
-            Assert.False(token1a.Equals(token2a));
-            Assert.False(token1a.Equals(token1c));
-        }
-
-        [Fact]
-        public void Should_provide_correct_hash_codes()
-        {
-            var id1 = Guid.NewGuid();
-            var id2 = Guid.NewGuid();
-
-            object token1a = NamedId.Of(id1, "my-name1");
-            object token1b = NamedId.Of(id1, "my-name1");
-            object token1c = NamedId.Of(id1, "my-name2");
-            object token2a = NamedId.Of(id2, "my-name1");
 
-            Assert.Equal(token1a.GetHashCode(), token1b.GetHashCode());
+            Assert.NotEqual(named_id1_name1_a, named_id2_name1);
+            Assert.NotEqual(named_id1_name1_a.GetHashCode(), named_id2_name1.GetHashCode());
+            Assert.False(named_id1_name1_a.Equals((object)named_id2_name1));
 
-            Assert.NotEqual(token1a.GetHashCode(), token2a.GetHashCode());
+            Assert.NotEqual(named_id1_name1_a, named_id1_name2);
-            Assert.NotEqual(token1a.GetHashCode(), token1c.GetHashCode());
+            Assert.NotEqual(named_id1_name1_a.GetHashCode(), named_id1_name2.GetHashCode());
+            Assert.False(named_id1_name1_a.Equals((object)named_id1_name2));
         }
 
         [Fact]

tests/Squidex.Infrastructure.Tests/RefTokenTests.cs

@@ -70,39 +70,23 @@ namespace Squidex.Infrastructure
         [Fact]
         public void Should_make_correct_equal_comparisons()
         {
-            var token1a = RefToken.Parse("client:client1");
+            var token_type1_id1_a = RefToken.Parse("type1:client1");
-            var token1b = RefToken.Parse("client:client1");
+            var token_type1_id1_b = RefToken.Parse("type1:client1");
-            var token2a = RefToken.Parse("client:client2");
 
-            Assert.True(token1a.Equals(token1b));
+            var token_type2_id1 = RefToken.Parse("type2:client1");
+            var token_type1_id2 = RefToken.Parse("type1:client2");
 
-            Assert.False(token1a.Equals(token2a));
+            Assert.Equal(token_type1_id1_a, token_type1_id1_b);
-        }
+            Assert.Equal(token_type1_id1_a.GetHashCode(), token_type1_id1_b.GetHashCode());
-
+            Assert.True(token_type1_id1_a.Equals((object)token_type1_id1_b));
-        [Fact]
-        public void Should_make_correct_object_equal_comparisons()
-        {
-            object token1a = RefToken.Parse("client:client1");
-            object token1b = RefToken.Parse("client:client1");
-            object token2a = RefToken.Parse("client:client2");
-
-            Assert.True(token1a.Equals(token1b));
-
-            Assert.False(token1a.Equals(token2a));
-            Assert.False(token1b.Equals(token2a));
-        }
-
-        [Fact]
-        public void Should_provide_correct_hash_codes()
-        {
-            var token1a = RefToken.Parse("client:client1");
-            var token1b = RefToken.Parse("client:client1");
-            var token2a = RefToken.Parse("client:client2");
 
-            Assert.Equal(token1a.GetHashCode(), token1b.GetHashCode());
+            Assert.NotEqual(token_type1_id1_a, token_type2_id1);
+            Assert.NotEqual(token_type1_id1_a.GetHashCode(), token_type2_id1.GetHashCode());
+            Assert.False(token_type1_id1_a.Equals((object)token_type2_id1));
 
-            Assert.NotEqual(token1a.GetHashCode(), token2a.GetHashCode());
+            Assert.NotEqual(token_type1_id1_a, token_type1_id2);
-            Assert.NotEqual(token1b.GetHashCode(), token2a.GetHashCode());
+            Assert.NotEqual(token_type1_id1_a.GetHashCode(), token_type1_id2.GetHashCode());
+            Assert.False(token_type1_id1_a.Equals((object)token_type1_id2));
         }
 
         [Fact]

tests/Squidex.Infrastructure.Tests/TestHelpers/JsonHelper.cs

@@ -28,6 +28,7 @@ namespace Squidex.Infrastructure.TestHelpers
                     new ClaimsPrincipalConverter(),
                     new InstantConverter(),
                     new JsonValueConverter(),
+                    new EnvelopeHeadersConverter(),
                     new LanguageConverter(),
                     new NamedGuidIdConverter(),
                     new NamedLongIdConverter(),