diff --git a/src/Squidex.Domain.Apps.Core.Operations/HandleRules/IRuleTriggerHandler.cs b/src/Squidex.Domain.Apps.Core.Operations/HandleRules/IRuleTriggerHandler.cs index 47351b4f5..5c8cff42e 100644 --- a/src/Squidex.Domain.Apps.Core.Operations/HandleRules/IRuleTriggerHandler.cs +++ b/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); } } diff --git a/src/Squidex.Domain.Apps.Core.Operations/HandleRules/RuleService.cs b/src/Squidex.Domain.Apps.Core.Operations/HandleRules/RuleService.cs index 9b3eca324..32b8eddde 100644 --- a/src/Squidex.Domain.Apps.Core.Operations/HandleRules/RuleService.cs +++ b/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(); - - var enrichedEvent = await eventEnricher.EnrichAsync(appEventEnvelope); - - if (!triggerHandler.Triggers(enrichedEvent, rule.Trigger)) + if (!triggerHandler.Triggers(@event.Payload, rule.Trigger)) { return null; } @@ -106,6 +102,15 @@ namespace Squidex.Domain.Apps.Core.HandleRules return null; } + var appEventEnvelope = @event.To(); + + 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); diff --git a/src/Squidex.Domain.Apps.Core.Operations/HandleRules/RuleTriggerHandler.cs b/src/Squidex.Domain.Apps.Core.Operations/HandleRules/RuleTriggerHandler.cs index 1f881f586..b6ae11c04 100644 --- a/src/Squidex.Domain.Apps.Core.Operations/HandleRules/RuleTriggerHandler.cs +++ b/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 : IRuleTriggerHandler where T : RuleTrigger + public abstract class RuleTriggerHandler : 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; + } } } diff --git a/src/Squidex.Domain.Apps.Core.Operations/HandleRules/Triggers/AssetChangedTriggerHandler.cs b/src/Squidex.Domain.Apps.Core.Operations/HandleRules/Triggers/AssetChangedTriggerHandler.cs index 6132ac557..3aa2b107b 100644 --- a/src/Squidex.Domain.Apps.Core.Operations/HandleRules/Triggers/AssetChangedTriggerHandler.cs +++ b/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 + public sealed class AssetChangedTriggerHandler : RuleTriggerHandler { 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); - } - - private bool MatchsType(AssetChangedTriggerV2 trigger, EnrichedAssetEvent assetEvent) - { - return string.IsNullOrWhiteSpace(trigger.Condition) || scriptEngine.Evaluate("event", assetEvent, trigger.Condition); + return string.IsNullOrWhiteSpace(trigger.Condition) || scriptEngine.Evaluate("event", @event, trigger.Condition); } } } diff --git a/src/Squidex.Domain.Apps.Core.Operations/HandleRules/Triggers/ContentChangedTriggerHandler.cs b/src/Squidex.Domain.Apps.Core.Operations/HandleRules/Triggers/ContentChangedTriggerHandler.cs index fc2e84891..c27ffc5c2 100644 --- a/src/Squidex.Domain.Apps.Core.Operations/HandleRules/Triggers/ContentChangedTriggerHandler.cs +++ b/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 + public sealed class ContentChangedTriggerHandler : RuleTriggerHandler { 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 @eventId) + { + return @eventId.Id == schema.SchemaId; } private bool MatchsCondition(ContentChangedTriggerSchemaV2 schema, EnrichedSchemaEvent @event) diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/RuleServiceTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/RuleServiceTests.cs index cab02a7c7..24397e3cb 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/RuleServiceTests.cs +++ b/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>.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>.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>.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>.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.Ignored, ruleConfig.Trigger)) + .Returns(false); + + var job = await sut.CreateJobAsync(ruleConfig, ruleEnvelope); + + Assert.Null(job); + + A.CallTo(() => eventEnricher.EnrichAsync(A>.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.Ignored, ruleConfig.Trigger)) + .Returns(true); + A.CallTo(() => ruleTriggerHandler.Triggers(A.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.Ignored, ruleConfig.Trigger)) - .Returns(true); - A.CallTo(() => ruleActionHandler.CreateJobAsync(A.Ignored, ruleConfig.Action)) .Returns((actionDescription, actionData)); var job = await sut.CreateJobAsync(ruleConfig, ruleEnvelope); Assert.Null(job); + + A.CallTo(() => eventEnricher.EnrichAsync(A>.Ignored)) + .MustNotHaveHappened(); } [Fact] @@ -184,6 +216,9 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules A.CallTo(() => ruleTriggerHandler.Triggers(A.Ignored, ruleConfig.Trigger)) .Returns(true); + A.CallTo(() => ruleTriggerHandler.Triggers(A.Ignored, ruleConfig.Trigger)) + .Returns(true); + A.CallTo(() => ruleActionHandler.CreateJobAsync(A.Ignored, ruleConfig.Action)) .Returns((actionDescription, new ValidData { Value = 10 })); diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/Triggers/AssetChangedTriggerTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/Triggers/AssetChangedTriggerTests.cs index 9bd3890ef..976d24ac3 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/Triggers/AssetChangedTriggerTests.cs +++ b/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.Ignored, "true")) + .Returns(true); + + A.CallTo(() => scriptEngine.Evaluate("event", A.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(); - - var result = sut.Triggers(new EnrichedAssetEvent(), trigger); + TestForCondition(string.Empty, trigger => + { + var result = sut.Triggers(new ContentCreated(), trigger); - Assert.True(result); - - A.CallTo(() => scriptEngine.Evaluate(A.Ignored, A.Ignored, A.Ignored)) - .MustNotHaveHappened(); + Assert.False(result); + }); } [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 }; - - var result = sut.Triggers(new EnrichedAssetEvent(), trigger); - - Assert.True(result); + TestForCondition(string.Empty, trigger => + { + var result = sut.Triggers(new AssetCreated(), trigger); - A.CallTo(() => scriptEngine.Evaluate(A.Ignored, A.Ignored, A.Ignored)) - .MustNotHaveHappened(); + Assert.True(result); + }); } [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(); - - A.CallTo(() => scriptEngine.Evaluate("event", @event, trigger.Condition)) - .Returns(true); + Assert.False(result); + }); + } - 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)) - .Returns(false); + [Fact] + 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 action) + { + var trigger = new AssetChangedTriggerV2 { Condition = condition }; + + action(trigger); + + if (string.IsNullOrWhiteSpace(condition)) + { + A.CallTo(() => scriptEngine.Evaluate("event", A.Ignored, condition)) + .MustNotHaveHappened(); + } + else + { + A.CallTo(() => scriptEngine.Evaluate("event", A.Ignored, condition)) + .MustHaveHappened(); + } } } } diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/Triggers/ContentChangedTriggerTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/Triggers/ContentChangedTriggerTests.cs index fd65cb6ef..297495f6f 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/Triggers/ContentChangedTriggerTests.cs +++ b/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.Ignored, "true")) + .Returns(true); + + A.CallTo(() => scriptEngine.Evaluate("event", A.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(); - - var @event = new EnrichedContentEvent { SchemaId = SchemaMatch }; + TestForTrigger(handleAll: true, schemaId: null, condition: null, action: trigger => + { + 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.Ignored, A.Ignored, A.Ignored)) - .MustNotHaveHappened(); + Assert.False(result); + }); } [Fact] - public void Should_trigger_when_cathing_all_events() + public void Should_trigger_precheck_when_handling_all_events() { - var trigger = new ContentChangedTriggerV2 { HandleAll = true }; - - var @event = new EnrichedContentEvent { SchemaId = SchemaMatch }; + TestForTrigger(handleAll: true, schemaId: SchemaMatch, condition: null, action: trigger => + { + 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.Ignored, A.Ignored, A.Ignored)) - .MustNotHaveHappened(); + Assert.True(result); + }); } [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(new List - { - new ContentChangedTriggerSchemaV2 - { - SchemaId = SchemaMatch.Id - } - }) - }; - - var @event = new EnrichedContentEvent { SchemaId = SchemaMatch }; + var result = sut.Triggers(new ContentCreated { SchemaId = SchemaMatch }, trigger); - 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.Ignored, A.Ignored, A.Ignored)) - .MustNotHaveHappened(); + Assert.False(result); + }); } [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(new List - { - new ContentChangedTriggerSchemaV2 - { - SchemaId = SchemaNonMatch.Id - } - }) - }; - - var @event = new EnrichedContentEvent { SchemaId = SchemaMatch }; + var result = sut.Triggers(new EnrichedContentEvent { SchemaId = SchemaMatch }, trigger); - 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.Ignored, A.Ignored, A.Ignored)) - .MustNotHaveHappened(); + Assert.True(result); + }); } [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(new List - { - new ContentChangedTriggerSchemaV2 - { - SchemaId = SchemaMatch.Id, Condition = string.Empty - } - }) - }; + var result = sut.Triggers(new EnrichedContentEvent { SchemaId = SchemaMatch }, trigger); - var @event = new EnrichedContentEvent { SchemaId = SchemaMatch }; - - var result = sut.Triggers(@event, trigger); + Assert.True(result); + }); + } - 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.Ignored, A.Ignored, A.Ignored)) - .MustNotHaveHappened(); + Assert.True(result); + }); } [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(new List - { - new ContentChangedTriggerSchemaV2 - { - SchemaId = SchemaMatch.Id, Condition = "true" - } - }) - }; + var result = sut.Triggers(new EnrichedContentEvent { SchemaId = SchemaMatch }, trigger); - var @event = new EnrichedContentEvent { SchemaId = SchemaMatch }; - - A.CallTo(() => scriptEngine.Evaluate("event", @event, "true")) - .Returns(true); + Assert.False(result); + }); + } - 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] - public void Should_not_trigger_when_condition_does_not_matchs() + private void TestForTrigger(bool handleAll, NamedId schemaId, string condition, Action action) { - var trigger = new ContentChangedTriggerV2 + var trigger = new ContentChangedTriggerV2 { HandleAll = handleAll }; + + if (schemaId != null) { - Schemas = new ReadOnlyCollection(new List + trigger.Schemas = new ReadOnlyCollection(new List { new ContentChangedTriggerSchemaV2 { - SchemaId = SchemaMatch.Id, Condition = "false" + SchemaId = schemaId.Id, Condition = condition } - }) - }; + }); + } - var @event = new EnrichedContentEvent { SchemaId = SchemaMatch }; - - A.CallTo(() => scriptEngine.Evaluate("event", @event, "false")) - .Returns(false); + action(trigger); - var result = sut.Triggers(@event, trigger); - - Assert.False(result); + if (string.IsNullOrWhiteSpace(condition)) + { + A.CallTo(() => scriptEngine.Evaluate("event", A.Ignored, condition)) + .MustNotHaveHappened(); + } + else + { + A.CallTo(() => scriptEngine.Evaluate("event", A.Ignored, condition)) + .MustHaveHappened(); + } } } }