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

// ==========================================================================
//  Squidex Headless CMS
// ==========================================================================
//  Copyright (c) Squidex UG (haftungsbeschränkt)
//  All rights reserved. Licensed under the MIT license.
// ==========================================================================

using System;
using System.Collections.Generic;
using Squidex.Domain.Apps.Core.Contents;
using Squidex.Domain.Apps.Core.HandleRules;
using Squidex.Domain.Apps.Core.HandleRules.Triggers;
using Squidex.Domain.Apps.Core.Rules.Triggers;
using Squidex.Domain.Apps.Events;
using Squidex.Domain.Apps.Events.Contents;
using Squidex.Domain.Apps.Events.Rules;
using Squidex.Domain.Apps.Events.Schemas;
using Squidex.Infrastructure;
using Squidex.Infrastructure.Collections;
using Squidex.Infrastructure.EventSourcing;
using Xunit;

#pragma warning disable SA1401 // Fields must be private

namespace Squidex.Domain.Apps.Core.Operations.HandleRules.Triggers
{
    public class ContentChangedTriggerTests
    {
        private readonly IRuleTriggerHandler sut = new ContentChangedTriggerHandler();
        private static readonly NamedId<Guid> SchemaMatch = NamedId.Of(Guid.NewGuid(), "my-schema1");
        private static readonly NamedId<Guid> SchemaNonMatch = NamedId.Of(Guid.NewGuid(), "my-schema2");

        public static IEnumerable<object[]> TestData = new[]
        {
            new object[] { 0, 1, 1, 1, 1, 0, 0, 0, new RuleCreated() },
            new object[] { 0, 1, 1, 1, 1, 0, 0, 0, new ContentCreated { SchemaId = SchemaNonMatch } },
            new object[] { 1, 1, 0, 0, 0, 0, 0, 0, new ContentCreated { SchemaId = SchemaMatch } },
            new object[] { 0, 0, 0, 0, 0, 0, 0, 0, new ContentCreated { SchemaId = SchemaMatch } },
            new object[] { 1, 0, 1, 0, 0, 0, 0, 0, new ContentUpdated { SchemaId = SchemaMatch } },
            new object[] { 0, 0, 0, 0, 0, 0, 0, 0, new ContentUpdated { SchemaId = SchemaMatch } },
            new object[] { 1, 0, 0, 1, 0, 0, 0, 0, new ContentDeleted { SchemaId = SchemaMatch } },
            new object[] { 0, 0, 0, 0, 0, 0, 0, 0, new ContentDeleted { SchemaId = SchemaMatch } },
            new object[] { 1, 1, 1, 1, 0, 0, 1, 0, new ContentStatusChanged { SchemaId = SchemaMatch, Change = StatusChange.Archived } },
            new object[] { 0, 1, 1, 1, 0, 0, 0, 0, new ContentStatusChanged { SchemaId = SchemaMatch, Change = StatusChange.Archived } },
            new object[] { 1, 0, 0, 0, 0, 0, 0, 1, new ContentStatusChanged { SchemaId = SchemaMatch, Change = StatusChange.Restored } },
            new object[] { 0, 0, 0, 0, 0, 0, 0, 0, new ContentStatusChanged { SchemaId = SchemaMatch, Change = StatusChange.Restored } },
            new object[] { 1, 0, 0, 0, 1, 0, 0, 0, new ContentStatusChanged { SchemaId = SchemaMatch, Change = StatusChange.Published } },
            new object[] { 0, 0, 0, 0, 0, 0, 0, 0, new ContentStatusChanged { SchemaId = SchemaMatch, Change = StatusChange.Published } },
            new object[] { 1, 1, 1, 1, 0, 1, 0, 0, new ContentStatusChanged { SchemaId = SchemaMatch, Change = StatusChange.Unpublished } },
            new object[] { 0, 1, 1, 1, 0, 0, 0, 0, new ContentStatusChanged { SchemaId = SchemaMatch, Change = StatusChange.Unpublished } },
            new object[] { 0, 1, 1, 1, 1, 0, 0, 0, new SchemaCreated { SchemaId = SchemaNonMatch } }
        };

        [Fact]
        public void Should_return_false_when_trigger_contains_no_schemas()
        {
            var trigger = new ContentChangedTrigger();

            var result = sut.Triggers(new Envelope<AppEvent>(new ContentCreated()), trigger);

            Assert.False(result);
        }

        [Fact]
        public void Should_return_true_when_cathing_all_events()
        {
            var trigger = new ContentChangedTrigger { HandleAll = true };

            var result = sut.Triggers(new Envelope<AppEvent>(new ContentCreated()), trigger);

            Assert.True(result);
        }

        [Theory]
        [MemberData(nameof(TestData))]
        public void Should_return_result_depending_on_event(int expected,
            int sendCreate,
            int sendUpdate,
            int sendDelete,
            int sendPublish,
            int sendUnpublish,
            int sendArchive,
            int sendRestore,
            AppEvent @event)
        {
            var trigger = new ContentChangedTrigger
            {
                Schemas = ReadOnlyCollection.Create(
                    new ContentChangedTriggerSchema
                    {
                        SendCreate = sendCreate == 1,
                        SendUpdate = sendUpdate == 1,
                        SendDelete = sendDelete == 1,
                        SendPublish = sendPublish == 1,
                        SendUnpublish = sendUnpublish == 1,
                        SendArchived = sendArchive == 1,
                        SendRestore = sendRestore == 1,
                        SchemaId = SchemaMatch.Id
                    })
            };

            var result = sut.Triggers(new Envelope<AppEvent>(@event), trigger);

            Assert.Equal(expected == 1, result);
        }
    }
}