Performance improvements with prechecks.

src/Squidex.Domain.Apps.Core.Operations/HandleRules/IRuleTriggerHandler.cs

@@ -8,6 +8,7 @@
 using System;
 using Squidex.Domain.Apps.Core.HandleRules.EnrichedEvents;
 using Squidex.Domain.Apps.Core.Rules;
+using Squidex.Infrastructure.EventSourcing;
 
 namespace Squidex.Domain.Apps.Core.HandleRules
 {
@@ -16,5 +17,7 @@ namespace Squidex.Domain.Apps.Core.HandleRules
         Type TriggerType { get; }
 
         bool Triggers(EnrichedEvent @event, RuleTrigger trigger);
+
+        bool Triggers(IEvent @event, RuleTrigger trigger);
     }
 }

src/Squidex.Domain.Apps.Core.Operations/HandleRules/RuleService.cs

@@ -83,11 +83,7 @@ namespace Squidex.Domain.Apps.Core.HandleRules
                 return null;
             }
 
-            var appEventEnvelope = @event.To<AppEvent>();
+            if (!triggerHandler.Triggers(@event.Payload, rule.Trigger))
-
-            var enrichedEvent = await eventEnricher.EnrichAsync(appEventEnvelope);
-
-            if (!triggerHandler.Triggers(enrichedEvent, rule.Trigger))
             {
                 return null;
             }
@@ -106,6 +102,15 @@ namespace Squidex.Domain.Apps.Core.HandleRules
                 return null;
             }
 
+            var appEventEnvelope = @event.To<AppEvent>();
+
+            var enrichedEvent = await eventEnricher.EnrichAsync(appEventEnvelope);
+
+            if (!triggerHandler.Triggers(enrichedEvent, rule.Trigger))
+            {
+                return null;
+            }
+
             var actionName = typeNameRegistry.GetName(actionType);
             var actionData = await actionHandler.CreateJobAsync(enrichedEvent, rule.Action);
 

src/Squidex.Domain.Apps.Core.Operations/HandleRules/RuleTriggerHandler.cs

@@ -8,21 +8,35 @@
 using System;
 using Squidex.Domain.Apps.Core.HandleRules.EnrichedEvents;
 using Squidex.Domain.Apps.Core.Rules;
+using Squidex.Infrastructure.EventSourcing;
 
 namespace Squidex.Domain.Apps.Core.HandleRules
 {
-    public abstract class RuleTriggerHandler<T> : IRuleTriggerHandler where T : RuleTrigger
+    public abstract class RuleTriggerHandler<TTrigger, TEvent, TEnrichedEvent> : IRuleTriggerHandler
+        where TTrigger : RuleTrigger
+        where TEvent : IEvent
+        where TEnrichedEvent : EnrichedEvent
     {
         public Type TriggerType
         {
-            get { return typeof(T); }
+            get { return typeof(TTrigger); }
         }
 
         bool IRuleTriggerHandler.Triggers(EnrichedEvent @event, RuleTrigger trigger)
         {
-            return Triggers(@event, (T)trigger);
+            return @event is TEnrichedEvent e && Triggers(e, (TTrigger)trigger);
         }
 
-        protected abstract bool Triggers(EnrichedEvent @event, T trigger);
+        bool IRuleTriggerHandler.Triggers(IEvent @event, RuleTrigger trigger)
+        {
+            return @event is TEvent e && Triggers(e, (TTrigger)trigger);
+        }
+
+        protected abstract bool Triggers(TEnrichedEvent @event, TTrigger trigger);
+
+        protected virtual bool Triggers(TEvent @event, TTrigger trigger)
+        {
+            return true;
+        }
     }
 }

src/Squidex.Domain.Apps.Core.Operations/HandleRules/Triggers/AssetChangedTriggerHandler.cs

@@ -8,11 +8,12 @@
 using Squidex.Domain.Apps.Core.HandleRules.EnrichedEvents;
 using Squidex.Domain.Apps.Core.Rules.Triggers;
 using Squidex.Domain.Apps.Core.Scripting;
+using Squidex.Domain.Apps.Events.Assets;
 using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Core.HandleRules.Triggers
 {
-    public sealed class AssetChangedTriggerHandler : RuleTriggerHandler<AssetChangedTriggerV2>
+    public sealed class AssetChangedTriggerHandler : RuleTriggerHandler<AssetChangedTriggerV2, AssetEvent, EnrichedAssetEvent>
     {
         private readonly IScriptEngine scriptEngine;
 
@@ -23,14 +24,9 @@ namespace Squidex.Domain.Apps.Core.HandleRules.Triggers
             this.scriptEngine = scriptEngine;
         }
 
-        protected override bool Triggers(EnrichedEvent @event, AssetChangedTriggerV2 trigger)
+        protected override bool Triggers(EnrichedAssetEvent @event, AssetChangedTriggerV2 trigger)
         {
-            return @event is EnrichedAssetEvent assetEvent && MatchsType(trigger, assetEvent);
+            return string.IsNullOrWhiteSpace(trigger.Condition) || scriptEngine.Evaluate("event", @event, trigger.Condition);
-        }
-
-        private bool MatchsType(AssetChangedTriggerV2 trigger, EnrichedAssetEvent assetEvent)
-        {
-            return string.IsNullOrWhiteSpace(trigger.Condition) || scriptEngine.Evaluate("event", assetEvent, trigger.Condition);
         }
     }
 }

src/Squidex.Domain.Apps.Core.Operations/HandleRules/Triggers/ContentChangedTriggerHandler.cs

@@ -5,14 +5,16 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
+using System;
 using Squidex.Domain.Apps.Core.HandleRules.EnrichedEvents;
 using Squidex.Domain.Apps.Core.Rules.Triggers;
 using Squidex.Domain.Apps.Core.Scripting;
+using Squidex.Domain.Apps.Events.Contents;
 using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Core.HandleRules.Triggers
 {
-    public sealed class ContentChangedTriggerHandler : RuleTriggerHandler<ContentChangedTriggerV2>
+    public sealed class ContentChangedTriggerHandler : RuleTriggerHandler<ContentChangedTriggerV2, ContentEvent, EnrichedContentEvent>
     {
         private readonly IScriptEngine scriptEngine;
 
@@ -23,18 +25,18 @@ namespace Squidex.Domain.Apps.Core.HandleRules.Triggers
             this.scriptEngine = scriptEngine;
         }
 
-        protected override bool Triggers(EnrichedEvent @event, ContentChangedTriggerV2 trigger)
+        protected override bool Triggers(ContentEvent @event, ContentChangedTriggerV2 trigger)
         {
             if (trigger.HandleAll)
             {
                 return true;
             }
 
-            if (trigger.Schemas != null && @event is EnrichedSchemaEvent schemaEvent)
+            if (trigger.Schemas != null)
             {
                 foreach (var schema in trigger.Schemas)
                 {
-                    if (MatchsSchema(schema, schemaEvent) && MatchsCondition(schema, schemaEvent))
+                    if (MatchsSchema(schema, @event.SchemaId))
                     {
                         return true;
                     }
@@ -44,9 +46,30 @@ namespace Squidex.Domain.Apps.Core.HandleRules.Triggers
             return false;
         }
 
-        private bool MatchsSchema(ContentChangedTriggerSchemaV2 schema, EnrichedSchemaEvent @event)
+        protected override bool Triggers(EnrichedContentEvent @event, ContentChangedTriggerV2 trigger)
         {
-            return @event.SchemaId.Id == schema.SchemaId;
+            if (trigger.HandleAll)
+            {
+                return true;
+            }
+
+            if (trigger.Schemas != null)
+            {
+                foreach (var schema in trigger.Schemas)
+                {
+                    if (MatchsSchema(schema, @event.SchemaId) && MatchsCondition(schema, @event))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private bool MatchsSchema(ContentChangedTriggerSchemaV2 schema, NamedId<Guid> @eventId)
+        {
+            return @eventId.Id == schema.SchemaId;
         }
 
         private bool MatchsCondition(ContentChangedTriggerSchemaV2 schema, EnrichedSchemaEvent @event)

tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/RuleServiceTests.cs

@@ -91,6 +91,9 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             var job = await sut.CreateJobAsync(ruleConfig, ruleEnvelope);
 
             Assert.Null(job);
+
+            A.CallTo(() => eventEnricher.EnrichAsync(A<Envelope<AppEvent>>.Ignored))
+                .MustNotHaveHappened();
         }
 
         [Fact]
@@ -102,6 +105,9 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             var job = await sut.CreateJobAsync(ruleConfig, ruleEnvelope);
 
             Assert.Null(job);
+
+            A.CallTo(() => eventEnricher.EnrichAsync(A<Envelope<AppEvent>>.Ignored))
+                .MustNotHaveHappened();
         }
 
         [Fact]
@@ -113,6 +119,9 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             var job = await sut.CreateJobAsync(ruleConfig, ruleEnvelope);
 
             Assert.Null(job);
+
+            A.CallTo(() => eventEnricher.EnrichAsync(A<Envelope<AppEvent>>.Ignored))
+                .MustNotHaveHappened();
         }
 
         [Fact]
@@ -124,14 +133,37 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             var job = await sut.CreateJobAsync(ruleConfig, ruleEnvelope);
 
             Assert.Null(job);
+
+            A.CallTo(() => eventEnricher.EnrichAsync(A<Envelope<AppEvent>>.Ignored))
+                .MustNotHaveHappened();
         }
 
         [Fact]
-        public async Task Should_not_create_if_not_triggered()
+        public async Task Should_not_create_job_if_not_triggered_with_precheck()
         {
             var ruleConfig = ValidRule();
             var ruleEnvelope = Envelope.Create(new ContentCreated());
 
+            A.CallTo(() => ruleTriggerHandler.Triggers(A<IEvent>.Ignored, ruleConfig.Trigger))
+                .Returns(false);
+
+            var job = await sut.CreateJobAsync(ruleConfig, ruleEnvelope);
+
+            Assert.Null(job);
+
+            A.CallTo(() => eventEnricher.EnrichAsync(A<Envelope<AppEvent>>.Ignored))
+                .MustNotHaveHappened();
+        }
+
+        [Fact]
+        public async Task Should_not_create_job_if_not_triggered()
+        {
+            var ruleConfig = ValidRule();
+            var ruleEnvelope = Envelope.Create(new ContentCreated());
+
+            A.CallTo(() => ruleTriggerHandler.Triggers(A<IEvent>.Ignored, ruleConfig.Trigger))
+                .Returns(true);
+
             A.CallTo(() => ruleTriggerHandler.Triggers(A<EnrichedEvent>.Ignored, ruleConfig.Trigger))
                 .Returns(false);
 
@@ -155,15 +187,15 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             A.CallTo(() => clock.GetCurrentInstant())
                 .Returns(now);
 
-            A.CallTo(() => ruleTriggerHandler.Triggers(A<EnrichedEvent>.Ignored, ruleConfig.Trigger))
-                .Returns(true);
-
             A.CallTo(() => ruleActionHandler.CreateJobAsync(A<EnrichedEvent>.Ignored, ruleConfig.Action))
                 .Returns((actionDescription, actionData));
 
             var job = await sut.CreateJobAsync(ruleConfig, ruleEnvelope);
 
             Assert.Null(job);
+
+            A.CallTo(() => eventEnricher.EnrichAsync(A<Envelope<AppEvent>>.Ignored))
+                .MustNotHaveHappened();
         }
 
         [Fact]
@@ -184,6 +216,9 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             A.CallTo(() => ruleTriggerHandler.Triggers(A<EnrichedEvent>.Ignored, ruleConfig.Trigger))
                 .Returns(true);
 
+            A.CallTo(() => ruleTriggerHandler.Triggers(A<IEvent>.Ignored, ruleConfig.Trigger))
+                .Returns(true);
+
             A.CallTo(() => ruleActionHandler.CreateJobAsync(A<EnrichedEvent>.Ignored, ruleConfig.Action))
                 .Returns((actionDescription, new ValidData { Value = 10 }));
 

tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/Triggers/AssetChangedTriggerTests.cs

@@ -5,12 +5,15 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
+using System;
 using FakeItEasy;
 using Squidex.Domain.Apps.Core.HandleRules;
 using Squidex.Domain.Apps.Core.HandleRules.EnrichedEvents;
 using Squidex.Domain.Apps.Core.HandleRules.Triggers;
 using Squidex.Domain.Apps.Core.Rules.Triggers;
 using Squidex.Domain.Apps.Core.Scripting;
+using Squidex.Domain.Apps.Events.Assets;
+using Squidex.Domain.Apps.Events.Contents;
 using Xunit;
 
 namespace Squidex.Domain.Apps.Core.Operations.HandleRules.Triggers
@@ -23,62 +26,96 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules.Triggers
         public AssetChangedTriggerTests()
         {
             sut = new AssetChangedTriggerHandler(scriptEngine);
+
+            A.CallTo(() => scriptEngine.Evaluate("event", A<object>.Ignored, "true"))
+                .Returns(true);
+
+            A.CallTo(() => scriptEngine.Evaluate("event", A<object>.Ignored, "false"))
+                .Returns(false);
         }
 
         [Fact]
-        public void Should_trigger_when_condition_is_null()
+        public void Should_not_trigger_precheck_when_event_type_not_correct()
         {
-            var trigger = new AssetChangedTriggerV2();
+            TestForCondition(string.Empty, trigger =>
-
+            {
-            var result = sut.Triggers(new EnrichedAssetEvent(), trigger);
+                var result = sut.Triggers(new ContentCreated(), trigger);
 
-            Assert.True(result);
+                Assert.False(result);
-
+            });
-            A.CallTo(() => scriptEngine.Evaluate(A<string>.Ignored, A<object>.Ignored, A<string>.Ignored))
-                .MustNotHaveHappened();
         }
 
         [Fact]
-        public void Should_trigger_when_condition_is_empty()
+        public void Should_trigger_precheck_when_event_type_correct()
         {
-            var trigger = new AssetChangedTriggerV2 { Condition = string.Empty };
+            TestForCondition(string.Empty, trigger =>
-
+            {
-            var result = sut.Triggers(new EnrichedAssetEvent(), trigger);
+                var result = sut.Triggers(new AssetCreated(), trigger);
-
-            Assert.True(result);
 
-            A.CallTo(() => scriptEngine.Evaluate(A<string>.Ignored, A<object>.Ignored, A<string>.Ignored))
+                Assert.True(result);
-                .MustNotHaveHappened();
+            });
         }
 
         [Fact]
-        public void Should_trigger_when_condition_matchs()
+        public void Should_not_trigger_check_when_event_type_not_correct()
         {
-            var trigger = new AssetChangedTriggerV2 { Condition = "true" };
+            TestForCondition(string.Empty, trigger =>
+            {
+                var result = sut.Triggers(new EnrichedContentEvent(), trigger);
 
-            var @event = new EnrichedAssetEvent();
+                Assert.False(result);
-
+            });
-            A.CallTo(() => scriptEngine.Evaluate("event", @event, trigger.Condition))
+        }
-                .Returns(true);
 
-            var result = sut.Triggers(@event, trigger);
+        [Fact]
+        public void Should_trigger_check_when_condition_is_empty()
+        {
+            TestForCondition(string.Empty, trigger =>
+            {
+                var result = sut.Triggers(new EnrichedAssetEvent(), trigger);
 
-            Assert.True(result);
+                Assert.True(result);
+            });
         }
 
         [Fact]
-        public void Should_not_trigger_when_condition_does_not_matchs()
+        public void Should_trigger_check_when_condition_matchs()
         {
-            var trigger = new AssetChangedTriggerV2 { Condition = "false" };
+            TestForCondition("true", trigger =>
+            {
+                var result = sut.Triggers(new EnrichedAssetEvent(), trigger);
 
-            var @event = new EnrichedAssetEvent();
+                Assert.True(result);
+            });
+        }
 
-            A.CallTo(() => scriptEngine.Evaluate("event", @event, trigger.Condition))
+        [Fact]
-                .Returns(false);
+        public void Should_not_trigger_check_when_condition_does_not_matchs()
+        {
+            TestForCondition("false", trigger =>
+            {
+                var result = sut.Triggers(new EnrichedAssetEvent(), trigger);
 
-            var result = sut.Triggers(@event, trigger);
+                Assert.False(result);
+            });
+        }
 
-            Assert.False(result);
+        private void TestForCondition(string condition, Action<AssetChangedTriggerV2> action)
+        {
+            var trigger = new AssetChangedTriggerV2 { Condition = condition };
+
+            action(trigger);
+
+            if (string.IsNullOrWhiteSpace(condition))
+            {
+                A.CallTo(() => scriptEngine.Evaluate("event", A<object>.Ignored, condition))
+                    .MustNotHaveHappened();
+            }
+            else
+            {
+                A.CallTo(() => scriptEngine.Evaluate("event", A<object>.Ignored, condition))
+                    .MustHaveHappened();
+            }
         }
     }
 }

tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/Triggers/ContentChangedTriggerTests.cs

@@ -14,10 +14,13 @@ using Squidex.Domain.Apps.Core.HandleRules.EnrichedEvents;
 using Squidex.Domain.Apps.Core.HandleRules.Triggers;
 using Squidex.Domain.Apps.Core.Rules.Triggers;
 using Squidex.Domain.Apps.Core.Scripting;
+using Squidex.Domain.Apps.Events.Assets;
+using Squidex.Domain.Apps.Events.Contents;
 using Squidex.Infrastructure;
 using Xunit;
 
 #pragma warning disable SA1401 // Fields must be private
+#pragma warning disable RECS0070
 
 namespace Squidex.Domain.Apps.Core.Operations.HandleRules.Triggers
 {
@@ -31,156 +34,173 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules.Triggers
         public ContentChangedTriggerTests()
         {
             sut = new ContentChangedTriggerHandler(scriptEngine);
+
+            A.CallTo(() => scriptEngine.Evaluate("event", A<object>.Ignored, "true"))
+                .Returns(true);
+
+            A.CallTo(() => scriptEngine.Evaluate("event", A<object>.Ignored, "false"))
+                .Returns(false);
         }
 
         [Fact]
-        public void Should_not_trigger_when_o_contains_no_schemas()
+        public void Should_not_trigger_precheck_when_event_type_not_correct()
         {
-            var trigger = new ContentChangedTriggerV2();
+            TestForTrigger(handleAll: true, schemaId: null, condition: null, action: trigger =>
-
+            {
-            var @event = new EnrichedContentEvent { SchemaId = SchemaMatch };
+                var result = sut.Triggers(new AssetCreated(), trigger);
 
-            var result = sut.Triggers(@event, trigger);
+                Assert.False(result);
+            });
+        }
 
-            Assert.False(result);
+        [Fact]
+        public void Should_not_trigger_precheck_when_trigger_contains_no_schemas()
+        {
+            TestForTrigger(handleAll: false, schemaId: null, condition: null, action: trigger =>
+            {
+                var result = sut.Triggers(new ContentCreated { SchemaId = SchemaMatch }, trigger);
 
-            A.CallTo(() => scriptEngine.Evaluate(A<string>.Ignored, A<object>.Ignored, A<string>.Ignored))
+                Assert.False(result);
-                .MustNotHaveHappened();
+            });
         }
 
         [Fact]
-        public void Should_trigger_when_cathing_all_events()
+        public void Should_trigger_precheck_when_handling_all_events()
         {
-            var trigger = new ContentChangedTriggerV2 { HandleAll = true };
+            TestForTrigger(handleAll: true, schemaId: SchemaMatch, condition: null, action: trigger =>
-
+            {
-            var @event = new EnrichedContentEvent { SchemaId = SchemaMatch };
+                var result = sut.Triggers(new ContentCreated { SchemaId = SchemaMatch }, trigger);
 
-            var result = sut.Triggers(@event, trigger);
+                Assert.True(result);
+            });
+        }
 
-            Assert.True(result);
+        [Fact]
+        public void Should_trigger_precheck_when_condition_is_empty()
+        {
+            TestForTrigger(handleAll: false, schemaId: SchemaMatch, condition: string.Empty, action: trigger =>
+            {
+                var result = sut.Triggers(new ContentCreated { SchemaId = SchemaMatch }, trigger);
 
-            A.CallTo(() => scriptEngine.Evaluate(A<string>.Ignored, A<object>.Ignored, A<string>.Ignored))
+                Assert.True(result);
-                .MustNotHaveHappened();
+            });
         }
 
         [Fact]
-        public void Should_trigger_when_condition_is_null()
+        public void Should_not_trigger_precheck_when_schema_id_does_not_match()
         {
-            var trigger = new ContentChangedTriggerV2
+            TestForTrigger(handleAll: false, schemaId: SchemaNonMatch, condition: null, action: trigger =>
             {
-                Schemas = new ReadOnlyCollection<ContentChangedTriggerSchemaV2>(new List<ContentChangedTriggerSchemaV2>
+                var result = sut.Triggers(new ContentCreated { SchemaId = SchemaMatch }, trigger);
-                {
-                    new ContentChangedTriggerSchemaV2
-                    {
-                        SchemaId = SchemaMatch.Id
-                    }
-                })
-            };
-
-            var @event = new EnrichedContentEvent { SchemaId = SchemaMatch };
 
-            var result = sut.Triggers(@event, trigger);
+                Assert.False(result);
+            });
+        }
 
-            Assert.True(result);
+        [Fact]
+        public void Should_not_trigger_check_when_event_type_not_correct()
+        {
+            TestForTrigger(handleAll: true, schemaId: null, condition: null, action: trigger =>
+            {
+                var result = sut.Triggers(new EnrichedAssetEvent(), trigger);
 
-            A.CallTo(() => scriptEngine.Evaluate(A<string>.Ignored, A<object>.Ignored, A<string>.Ignored))
+                Assert.False(result);
-                .MustNotHaveHappened();
+            });
         }
 
         [Fact]
-        public void Should_not_trigger_when_schema_id_does_not_match()
+        public void Should_not_trigger_check_when_trigger_contains_no_schemas()
         {
-            var trigger = new ContentChangedTriggerV2
+            TestForTrigger(handleAll: false, schemaId: null, condition: null, action: trigger =>
             {
-                Schemas = new ReadOnlyCollection<ContentChangedTriggerSchemaV2>(new List<ContentChangedTriggerSchemaV2>
+                var result = sut.Triggers(new EnrichedContentEvent { SchemaId = SchemaMatch }, trigger);
-                {
-                    new ContentChangedTriggerSchemaV2
-                    {
-                        SchemaId = SchemaNonMatch.Id
-                    }
-                })
-            };
-
-            var @event = new EnrichedContentEvent { SchemaId = SchemaMatch };
 
-            var result = sut.Triggers(@event, trigger);
+                Assert.False(result);
+            });
+        }
 
-            Assert.False(result);
+        [Fact]
+        public void Should_trigger_check_when_handling_all_events()
+        {
+            TestForTrigger(handleAll: true, schemaId: SchemaMatch, condition: null, action: trigger =>
+            {
+                var result = sut.Triggers(new EnrichedContentEvent { SchemaId = SchemaMatch }, trigger);
 
-            A.CallTo(() => scriptEngine.Evaluate(A<string>.Ignored, A<object>.Ignored, A<string>.Ignored))
+                Assert.True(result);
-                .MustNotHaveHappened();
+            });
         }
 
         [Fact]
-        public void Should_trigger_when_condition_is_empty()
+        public void Should_trigger_check_when_condition_is_empty()
         {
-            var trigger = new ContentChangedTriggerV2
+            TestForTrigger(handleAll: false, schemaId: SchemaMatch, condition: string.Empty, action: trigger =>
             {
-                Schemas = new ReadOnlyCollection<ContentChangedTriggerSchemaV2>(new List<ContentChangedTriggerSchemaV2>
+                var result = sut.Triggers(new EnrichedContentEvent { SchemaId = SchemaMatch }, trigger);
-                {
-                    new ContentChangedTriggerSchemaV2
-                    {
-                        SchemaId = SchemaMatch.Id, Condition = string.Empty
-                    }
-                })
-            };
 
-            var @event = new EnrichedContentEvent { SchemaId = SchemaMatch };
+                Assert.True(result);
-
+            });
-            var result = sut.Triggers(@event, trigger);
+        }
 
-            Assert.True(result);
+        [Fact]
+        public void Should_trigger_check_when_condition_matchs()
+        {
+            TestForTrigger(handleAll: false, schemaId: SchemaMatch, condition: "true", action: trigger =>
+            {
+                var result = sut.Triggers(new EnrichedContentEvent { SchemaId = SchemaMatch }, trigger);
 
-            A.CallTo(() => scriptEngine.Evaluate(A<string>.Ignored, A<object>.Ignored, A<string>.Ignored))
+                Assert.True(result);
-                .MustNotHaveHappened();
+            });
         }
 
         [Fact]
-        public void Should_trigger_when_condition_matchs()
+        public void Should_not_trigger_check_when_schema_id_does_not_match()
         {
-            var trigger = new ContentChangedTriggerV2
+            TestForTrigger(handleAll: false, schemaId: SchemaNonMatch, condition: null, action: trigger =>
             {
-                Schemas = new ReadOnlyCollection<ContentChangedTriggerSchemaV2>(new List<ContentChangedTriggerSchemaV2>
+                var result = sut.Triggers(new EnrichedContentEvent { SchemaId = SchemaMatch }, trigger);
-                {
-                    new ContentChangedTriggerSchemaV2
-                    {
-                        SchemaId = SchemaMatch.Id, Condition = "true"
-                    }
-                })
-            };
 
-            var @event = new EnrichedContentEvent { SchemaId = SchemaMatch };
+                Assert.False(result);
-
+            });
-            A.CallTo(() => scriptEngine.Evaluate("event", @event, "true"))
+        }
-                .Returns(true);
 
-            var result = sut.Triggers(@event, trigger);
+        [Fact]
+        public void Should_not_trigger_check_when_condition_does_not_matchs()
+        {
+            TestForTrigger(handleAll: false, schemaId: SchemaMatch, condition: "false", action: trigger =>
+            {
+                var result = sut.Triggers(new EnrichedContentEvent { SchemaId = SchemaMatch }, trigger);
 
-            Assert.True(result);
+                Assert.False(result);
+            });
         }
 
-        [Fact]
+        private void TestForTrigger(bool handleAll, NamedId<Guid> schemaId, string condition, Action<ContentChangedTriggerV2> action)
-        public void Should_not_trigger_when_condition_does_not_matchs()
         {
-            var trigger = new ContentChangedTriggerV2
+            var trigger = new ContentChangedTriggerV2 { HandleAll = handleAll };
+
+            if (schemaId != null)
             {
-                Schemas = new ReadOnlyCollection<ContentChangedTriggerSchemaV2>(new List<ContentChangedTriggerSchemaV2>
+                trigger.Schemas = new ReadOnlyCollection<ContentChangedTriggerSchemaV2>(new List<ContentChangedTriggerSchemaV2>
                 {
                     new ContentChangedTriggerSchemaV2
                     {
-                        SchemaId = SchemaMatch.Id, Condition = "false"
+                        SchemaId = schemaId.Id, Condition = condition
                     }
-                })
+                });
-            };
+            }
 
-            var @event = new EnrichedContentEvent { SchemaId = SchemaMatch };
+            action(trigger);
-
-            A.CallTo(() => scriptEngine.Evaluate("event", @event, "false"))
-                .Returns(false);
 
-            var result = sut.Triggers(@event, trigger);
+            if (string.IsNullOrWhiteSpace(condition))
-
+            {
-            Assert.False(result);
+                A.CallTo(() => scriptEngine.Evaluate("event", A<object>.Ignored, condition))
+                    .MustNotHaveHappened();
+            }
+            else
+            {
+                A.CallTo(() => scriptEngine.Evaluate("event", A<object>.Ignored, condition))
+                    .MustHaveHappened();
+            }
         }
     }
 }