Added code so that a json formatted rule with and empty conditionset would throw a missingconditionsetexception

Author: code-dispenser

Source/Conditionals.Core/Common/Exceptions/CustomExceptions.cs

@@ -131,4 +131,12 @@ public class ContextTypeAssemblyNotFoundException(string message, Exception? inn
 /// </summary>
 /// <param name="message">The message that describes the error.</param>
 /// <param name="innerException">The exception that is the cause of the current exception, or a null reference if no inner exception is specified.</param>
-public class EventNotFoundException(string message, Exception? innerException = null) : Exception(message, innerException) {}
+public class EventNotFoundException(string message, Exception? innerException = null) : Exception(message, innerException) {}
+
+
+/// <summary>
+/// Represents an exception that is thrown where there are no condition sets in the json." /> assemblies.
+/// Initialises a new instance of the <see cref="MissingConditionSetsException"/> class with a specified error message.
+/// </summary>
+/// <param name="message">The message that describes the error.</param>
+public class MissingConditionSetsException(string message) : Exception(message) { }

Source/Conditionals.Core/Common/FormatConverters/JsonRuleConverter.cs

@@ -31,7 +31,8 @@ internal static Rule<T> RuleFromJson<T>(string ruleJson)
         }
         catch (MissingExpressionToEvaluateException) { throw; }
         catch (ContextTypeAssemblyNotFoundException) { throw; }
-        catch (EventNotFoundException) { throw; }
+        catch (EventNotFoundException)               { throw; }
+        catch (MissingConditionSetsException)        { throw; }
         catch (Exception exception)
         {
             throw new RuleFromJsonException(GlobalStrings.Rule_From_Json_Exception_Message, exception);
@@ -45,14 +46,17 @@ internal static Rule<T> RuleFromJsonRule<T>(JsonRule<T> jsonRule)
         var tenantID            = jsonRule.TenantID  ?? GlobalStrings.Default_TenantID;
         var cultureID           = jsonRule.CultureID ?? GlobalStrings.Default_CultureID;
         var ruleEventDetails    = EventDetailsFromJson(jsonRule.RuleEventDetails);
+        int conditionSetCount   = jsonRule.ConditionSets.Count;
 
         if (jsonRule.RuleEventDetails != null && ruleEventDetails == null)
         {
             throw new EventNotFoundException(String.Format(GlobalStrings.Event_Not_Found_Exception_Message, jsonRule.RuleEventDetails.EventTypeName), null);//could not create the event details from the information in the JsonRule
         }
         var rule = (Rule<T>)Activator.CreateInstance(typeof(Rule<T>), ruleName, failureValue, ruleEventDetails, tenantID, cultureID)!;
 
-        for (int setIndex = 0; setIndex < jsonRule.ConditionSets?.Count; setIndex++)
+        if (conditionSetCount == 0) throw new MissingConditionSetsException(GlobalStrings.Missing_ConditionSets_Exception_Message);
+
+        for (int setIndex = 0; setIndex < conditionSetCount; setIndex++)
         {
             var jsonRuleConditionSet = jsonRule.ConditionSets[setIndex];
             var setName = jsonRuleConditionSet.SetName;

Source/Conditionals.Core/Common/Seeds/GlobalStrings.cs

@@ -33,6 +33,9 @@ internal static class GlobalStrings
     public const string Context_Type_Assembly_Not_Found_Exception_Message   = "The assembly for the type of data context used for the condition {0} could not be found in the assemblies for the current app domain.";
     public const string Event_Not_Found_Exception_Message                   = "The event named {0} could not be found whilst ingesting the json rule";
     public const string Invalid_System_DataType_Exception_Message           = "The data type for the rule named: {0} is invalid.";
+
+    public const string Missing_ConditionSets_Exception_Message             = "No condition sets were found in the rule.";
+
     //public const string In_Complete_Rule_Conversion_Exception_Message       = "A rule needs to contain at least one condition set with a condition before it can be converted";
 
     public const string Rule_Name_Property_Is_Missing_Or_Null_Message       = "No rule name";

Tests/Conditionals.Core.Tests.SharedDataAndFixtures/Data/StaticData.cs

@@ -643,4 +643,19 @@ public static string CustomerOneAsJsonString()
                                                                   ]
                                                                 }
                                                                 """;
+
+    public static readonly string JsonRuleMissingConditionSets = """
+                                                                {
+                                                                    "RuleName": "RuleOne",
+                                                                    "TenantID": "All_Tenants",
+                                                                    "CultureID": "en-GB",
+                                                                    "IsDisabled": false,
+                                                                    "FailureValue": 10,
+                                                                    "ValueTypeName": "Int32",
+                                                                    "RuleEventDetails": {
+                                                                    "EventTypeName": "Conditionals.Core.Tests.SharedDataAndFixtures.Events.RuleEventInt",
+                                                                    "EventWhenType": "OnFailure"
+                                                                    }
+                                                                }
+                                                                """;
 }

Tests/Conditionals.Core.Tests.Unit/Common/FormatConverters/JsonRuleConverterTests.cs

@@ -5,9 +5,11 @@
 using Conditionals.Core.Common.FormatConverters;
 using Conditionals.Core.Common.Models;
 using Conditionals.Core.Common.Seeds;
+using Conditionals.Core.Common.Utilities;
 using Conditionals.Core.Tests.SharedDataAndFixtures.Data;
 using Conditionals.Core.Tests.SharedDataAndFixtures.Events;
 using Conditionals.Core.Tests.SharedDataAndFixtures.Models;
+using Conditionals.Core.Tests.Unit.Common.Utilities;
 using FluentAssertions;
 using FluentAssertions.Execution;
 using Xunit;
@@ -16,6 +18,7 @@ namespace Conditionals.Core.Tests.Unit.Common.FormatConverters;
 
 public class JsonRuleConverterTests
 {
+
     [Fact]
     public void The_create_json_condition_from_boolean_condition_should_create_the_correct_ast_tree_condition_structure_part_of_the_json_rule_model()
     {
@@ -77,7 +80,15 @@ public void Json_with_an_event_type_that_cannot_be_found_and_or_created_should_t
     [Fact]
     public void TenantID_and_cultureID_should_be_set_to_defaults_if_null_converting_from_json_rule_to_rule()
     {
-        JsonRule<None> jsonRule = new() { RuleName="RuleOne", TenantID = null!, CultureID = null!, FailureValue = None.Value, IsDisabled = false, ConditionSets = null!, ValueTypeName = { } };
+        JsonCondition jsonCondition = new() {
+                AdditionalInfo  = [], ConditionEventDetails = null, ConditionName = "ConditionOne", ConditionType = ConditionType.CustomExpression.ToString(),
+                ContextTypeName = typeof(Customer).FullName, EvaluatorTypeName = "SomeEvaluator", ExpressionToEvaluate = "SomeExpression",
+                FailureMessage  = "Some failure message", LeftOperand = null, Operator = null, RightOperand = null,
+            };
+
+        List<JsonConditionSet<None>> jsonConditionSets = new() { new()  { BooleanConditions = jsonCondition, SetName ="SetONe", SetValue = None.Value } };
+
+        JsonRule<None> jsonRule = new() { RuleName="RuleOne", TenantID = null!, CultureID = null!, FailureValue = None.Value, IsDisabled = false, ConditionSets = jsonConditionSets, ValueTypeName = { } };
 
         var ruleFromJsonRule = JsonRuleConverter.RuleFromJsonRule(jsonRule);
 
@@ -95,17 +106,18 @@ public void Converting_a_json_rule_to_a_rule_with_a_bad_event_type_should_throw_
 
         FluentActions.Invoking(() => JsonRuleConverter.RuleFromJsonRule(jsonRule)).Should().ThrowExactly<EventNotFoundException>();
     }
-    [Fact]
-    public void Converting_a_json_rule_to_a_rule_with_null_rule_details_should_create_the_rule()
-    {
-        JsonRule<None> jsonRule = new() 
-        {
-            RuleName="RuleOne", TenantID = null!, CultureID = null!, FailureValue = None.Value, IsDisabled = false, ValueTypeName = { },
-            RuleEventDetails = null
-        };
+    //[Fact]
+    //public void Converting_a_json_rule_to_a_rule_with_null_rule_details_should_create_the_rule()
+    //{
+    //    JsonRule<None> jsonRule = new() 
+    //    {
+    //        RuleName="RuleOne", TenantID = null!, CultureID = null!, FailureValue = None.Value, IsDisabled = false, ValueTypeName = { },
+    //        RuleEventDetails = null,
+    //        ConditionSets = new List<JsonConditionSet<None>> { new JsonConditionSet<None> { BooleanConditions = null, SetName } }
+    //    };
 
-        FluentActions.Invoking(() => JsonRuleConverter.RuleFromJsonRule(jsonRule)).Should().NotThrow();
-    }
+    //    FluentActions.Invoking(() => JsonRuleConverter.RuleFromJsonRule(jsonRule)).Should().NotThrow();
+    //}
 
     [Fact]
     public void The_convert_to_boolean_condition_should_create_the_correct_boolean_condition_structure()
@@ -223,4 +235,21 @@ public void Converting_json_with_incorrect_event_when_types_should_default_to_th
     }
 
 
+
+
+    [Fact]
+    public void Converting_json_with_no_condition_sets_should_throw_a_missing_condition_sets_exception()
+    {
+        /*
+            * Needed to add a rule event just to ensure that the Conditionals.Core.Tests.SharedDataAndFixtures assembly gets included in
+            * AppDomain.CurrentDomain.GetAssemblies within the general utils class
+        */
+        RuleEventInt r = new RuleEventInt("Some Rule", false, 1, 1, "TenantID", []);
+
+        var jsonString = StaticData.JsonRuleMissingConditionSets;
+        
+        FluentActions.Invoking(() => JsonRuleConverter.RuleFromJson<int>(jsonString)).Should().ThrowExactly<MissingConditionSetsException>();
+
+    }
+
 }