fix: In App Message Template is Rendered for Email Step while fetching workflow data #90 (#92)

Co-authored-by: todd <[email protected]>

Author: toddb

src/Novu.Domain/JsonConverters/MessageTemplateConverter.cs

@@ -8,9 +8,20 @@ namespace Novu.Domain.JsonConverters;
 /// <summary>
 ///     Converts the incoming JSON stream into <see cref="IMessageTemplate" /> polymorphic type
 /// </summary>
+/// <example>
+///     <code>
+///        [JsonProperty("template")]
+///        [JsonConverter(typeof(MessageTemplateConverter))]
+///        public IMessageTemplate Template { get; set; }
+///     </code>
+/// </example>
 /// <see cref="EmailMessageTemplate" />
 /// <see cref="SmsMessageTemplate" />
-/// <see cref="InAppMessageTemplate" />
+/// <see cref="ChatMessageTemplate" />
+/// <see cref="PushMessageTemplate" />
+/// <see cref="DigestMessageTemplate" />
+/// <see cref="TriggerMessageTemplate" />
+/// <see cref="DelayMessageTemplate" />
 public class MessageTemplateConverter : JsonCreationConverter<IMessageTemplate>
 {
     protected override IMessageTemplate Create(Type objectType, JObject jObject)
@@ -30,13 +41,14 @@ protected override IMessageTemplate Create(Type objectType, JObject jObject)
                 return typeEnum switch
                 {
                     StepTypeEnum.InApp => new InAppMessageTemplate(),
-                    StepTypeEnum.Email => new InAppMessageTemplate(),
+                    StepTypeEnum.Email => new EmailMessageTemplate(),
                     StepTypeEnum.Sms => new SmsMessageTemplate(),
                     StepTypeEnum.Chat => new ChatMessageTemplate(),
                     StepTypeEnum.Push => new PushMessageTemplate(),
                     StepTypeEnum.Digest => new DigestMessageTemplate(),
                     StepTypeEnum.Trigger => new TriggerMessageTemplate(),
                     StepTypeEnum.Delay => new DelayMessageTemplate(),
+                    // important to throw to alert for new types
                     _ => throw new InvalidOperationException($"Unknown type {typeEnum}"),
                 };
             }

src/Novu.Domain/Models/Workflows/Step/Message/InAppMessageTemplate.cs

@@ -1,3 +1,4 @@
+using System.ComponentModel.DataAnnotations;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Novu.Domain.JsonConverters;
@@ -10,6 +11,7 @@ public class InAppMessageTemplate : BaseMessageTemplate, IMessageTemplate
 
     [JsonConverter(typeof(StringEnumConverter))]
     [JsonProperty("type")]
+    [Required]
     public StepTypeEnum Type { get; set; } = StepTypeEnum.InApp;
 
     /// <summary>

src/Novu.Tests/MicroTests/JsonConverters/MessageTemplateConverterTests.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using FluentAssertions;
+using Newtonsoft.Json;
+using Novu.Domain.JsonConverters;
+using Novu.Domain.Models.Workflows.Step.Message;
+using Xunit;
+
+namespace Novu.Tests.MicroTests.JsonConverters;
+
+public class MessageTemplateConverterTests
+{
+    public static IEnumerable<object[]> Data =>
+        new List<object[]>
+        {
+            new object[]
+            {
+                "empty type throws exception",
+                @"{ ""type"": """", }",
+                typeof(InAppMessageTemplate),
+                true,
+            },
+            new object[]
+            {
+                nameof(InAppMessageTemplate),
+                @"
+                {
+                    ""type"": ""in_app"",
+                }
+                ",
+                typeof(InAppMessageTemplate),
+                false,
+            },
+            new object[]
+            {
+                nameof(EmailMessageTemplate),
+                @"
+                {
+                    ""type"": ""email"",
+                }
+                ",
+                typeof(EmailMessageTemplate),
+                false,
+            },
+            new object[]
+            {
+                nameof(SmsMessageTemplate),
+                @"
+                {
+                    ""type"": ""sms"",
+                }
+                ",
+                typeof(SmsMessageTemplate),
+                false,
+            },
+            new object[]
+            {
+                nameof(ChatMessageTemplate),
+                @"
+                {
+                    ""type"": ""chat"",
+                }
+                ",
+                typeof(ChatMessageTemplate),
+                false,
+            },
+            new object[]
+            {
+                nameof(DigestMessageTemplate),
+                @"
+                {
+                    ""type"": ""digest"",
+                }
+                ",
+                typeof(DigestMessageTemplate),
+                false,
+            },
+            new object[]
+            {
+                nameof(TriggerMessageTemplate),
+                @"
+                {
+                    ""type"": ""trigger"",
+                }
+                ",
+                typeof(TriggerMessageTemplate),
+                false,
+            },
+            new object[]
+            {
+                nameof(DelayMessageTemplate),
+                @"
+                {
+                    ""type"": ""delay"",
+                }
+                ",
+                typeof(DelayMessageTemplate),
+                false,
+            },
+        };
+
+    [Theory]
+    [MemberData(nameof(Data))]
+    public void MessageTemplateType(string test, string json, Type t, bool throws)
+    {
+        JsonReader reader = new JsonTextReader(new StringReader(json));
+        while (reader.TokenType == JsonToken.None)
+        {
+            if (!reader.Read())
+            {
+                break;
+            }
+        }
+
+        if (throws)
+        {
+            Assert.ThrowsAny<Exception>(() =>
+                new MessageTemplateConverter()
+                    .ReadJson(reader, t, null, JsonSerializer.CreateDefault()));
+        }
+        else
+        {
+            new MessageTemplateConverter()
+                .ReadJson(reader, t, null, JsonSerializer.CreateDefault())
+                .GetType()
+                .Should()
+                .Be(t);
+        }
+    }
+}