squidex/tests/Squidex.Domain.Apps.Entities.Tests/Contents/ContentDomainObjectTests.cs

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

//using System;
//using FakeItEasy;
//using FluentAssertions;
//using NodaTime;
//using Squidex.Domain.Apps.Core.Contents;
//using Squidex.Domain.Apps.Entities.Contents.Commands;
//using Squidex.Domain.Apps.Entities.TestHelpers;
//using Squidex.Domain.Apps.Events.Contents;
//using Squidex.Infrastructure;
//using Squidex.Infrastructure.States;
//using Xunit;

//namespace Squidex.Domain.Apps.Entities.Contents
//{
//    public class ContentDomainObjectTests : HandlerTestBase<ContentDomainObject>
//    {
//        private readonly NamedContentData data =
//            new NamedContentData()
//                .AddField("field1",
//                    new ContentFieldData()
//                        .AddValue("iv", 1));
//        private readonly NamedContentData otherData =
//            new NamedContentData()
//                .AddField("field2",
//                    new ContentFieldData()
//                        .AddValue("iv", 2));
//        private readonly NamedContentData patched;
//        private readonly Guid contentId = Guid.NewGuid();
//        private readonly ContentDomainObject sut = new ContentDomainObject();

//        protected override Guid Id
//        {
//            get { return contentId; }
//        }

//        public ContentDomainObjectTests()
//        {
//            patched = otherData.MergeInto(data);

//            sut.ActivateAsync(Id, A.Fake<IStore<Guid>>());
//        }

//        [Fact]
//        public void Create_should_throw_exception_if_created()
//        {
//            sut.Create(CreateCommand(new CreateContent { Data = data }));

//            Assert.Throws<DomainException>(() =>
//            {
//                sut.Create(CreateContentCommand(new CreateContent { Data = data }));
//            });
//        }

//        [Fact]
//        public void Create_should_create_events()
//        {
//            sut.Create(CreateContentCommand(new CreateContent { Data = data }));

//            sut.GetUncomittedEvents()
//                .ShouldHaveSameEvents(
//                    CreateContentEvent(new ContentCreated { Data = data })
//                );
//        }

//        [Fact]
//        public void Create_should_also_publish_if_set_to_true()
//        {
//            sut.Create(CreateContentCommand(new CreateContent { Data = data, Publish = true }));

//            sut.GetUncomittedEvents()
//                .ShouldHaveSameEvents(
//                    CreateContentEvent(new ContentCreated { Data = data }),
//                    CreateContentEvent(new ContentStatusChanged { Status = Status.Published })
//                );
//        }

//        [Fact]
//        public void Update_should_throw_exception_if_not_created()
//        {
//            Assert.Throws<DomainException>(() =>
//            {
//                sut.Update(CreateContentCommand(new UpdateContent { Data = data }));
//            });
//        }

//        [Fact]
//        public void Update_should_throw_exception_if_content_is_deleted()
//        {
//            CreateContent();
//            DeleteContent();

//            Assert.Throws<DomainException>(() =>
//            {
//                sut.Update(CreateContentCommand(new UpdateContent()));
//            });
//        }

//        [Fact]
//        public void Update_should_create_events()
//        {
//            CreateContent();

//            sut.Update(CreateContentCommand(new UpdateContent { Data = otherData }));

//            sut.GetUncomittedEvents()
//                .ShouldHaveSameEvents(
//                    CreateContentEvent(new ContentUpdated { Data = otherData })
//                );
//        }

//        [Fact]
//        public void Update_should_not_create_event_for_same_data()
//        {
//            CreateContent();
//            UpdateContent();

//            sut.Update(CreateContentCommand(new UpdateContent { Data = data }));

//            sut.GetUncomittedEvents().Should().BeEmpty();
//        }

//        [Fact]
//        public void Patch_should_throw_exception_if_not_created()
//        {
//            Assert.Throws<DomainException>(() =>
//            {
//                sut.Patch(CreateContentCommand(new PatchContent { Data = data }));
//            });
//        }

//        [Fact]
//        public void Patch_should_throw_exception_if_content_is_deleted()
//        {
//            CreateContent();
//            DeleteContent();

//            Assert.Throws<DomainException>(() =>
//            {
//                sut.Patch(CreateContentCommand(new PatchContent()));
//            });
//        }

//        [Fact]
//        public void Patch_should_create_events()
//        {
//            CreateContent();
//            UpdateContent();

//            sut.Patch(CreateContentCommand(new PatchContent { Data = otherData }));

//            sut.GetUncomittedEvents()
//                .ShouldHaveSameEvents(
//                    CreateContentEvent(new ContentUpdated { Data = patched })
//                );
//        }

//        [Fact]
//        public void Patch_should_not_create_event_for_same_data()
//        {
//            CreateContent();
//            UpdateContent();

//            sut.Patch(CreateContentCommand(new PatchContent { Data = data }));

//            sut.GetUncomittedEvents().Should().BeEmpty();
//        }

//        [Fact]
//        public void ChangeStatus_should_throw_exception_if_not_created()
//        {
//            Assert.Throws<DomainException>(() =>
//            {
//                sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus()));
//            });
//        }

//        [Fact]
//        public void ChangeStatus_should_throw_exception_if_content_is_deleted()
//        {
//            CreateContent();
//            DeleteContent();

//            Assert.Throws<DomainException>(() =>
//            {
//                sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus()));
//            });
//        }

//        [Fact]
//        public void ChangeStatus_should_refresh_properties_and_create_events()
//        {
//            CreateContent();

//            sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus { Status = Status.Published }));

//            Assert.Equal(Status.Published, sut.Snapshot.Status);

//            sut.GetUncomittedEvents()
//                .ShouldHaveSameEvents(
//                    CreateContentEvent(new ContentStatusChanged { Status = Status.Published })
//                );
//        }

//        [Fact]
//        public void ChangeStatus_should_refresh_properties_and_create_scheduled_events_when_command_has_due_time()
//        {
//            CreateContent();

//            var dueTime = Instant.MaxValue;

//            sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus { Status = Status.Published, DueTime = dueTime }));

//            Assert.Equal(Status.Draft, sut.Snapshot.Status);
//            Assert.Equal(Status.Published, sut.Snapshot.ScheduledTo);
//            Assert.Equal(dueTime, sut.Snapshot.ScheduledAt);

//            sut.GetUncomittedEvents()
//                .ShouldHaveSameEvents(
//                    CreateContentEvent(new ContentStatusScheduled { Status = Status.Published, DueTime = dueTime })
//                );
//        }

//        [Fact]
//        public void Delete_should_throw_exception_if_not_created()
//        {
//            Assert.Throws<DomainException>(() =>
//            {
//                sut.Delete(CreateContentCommand(new DeleteContent()));
//            });
//        }

//        [Fact]
//        public void Delete_should_throw_exception_if_already_deleted()
//        {
//            CreateContent();
//            DeleteContent();

//            Assert.Throws<DomainException>(() =>
//            {
//                sut.Delete(CreateContentCommand(new DeleteContent()));
//            });
//        }

//        [Fact]
//        public void Delete_should_update_properties_and_create_events()
//        {
//            CreateContent();

//            sut.Delete(CreateContentCommand(new DeleteContent()));

//            Assert.True(sut.Snapshot.IsDeleted);

//            sut.GetUncomittedEvents()
//                .ShouldHaveSameEvents(
//                    CreateContentEvent(new ContentDeleted())
//                );
//        }

//        private void CreateContent()
//        {
//            sut.Create(CreateContentCommand(new CreateContent { Data = data }));
//            sut.ClearUncommittedEvents();
//        }

//        private void UpdateContent()
//        {
//            sut.Update(CreateContentCommand(new UpdateContent { Data = data }));
//            sut.ClearUncommittedEvents();
//        }

//        private void ChangeStatus(Status status)
//        {
//            sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus { Status = status }));
//            sut.ClearUncommittedEvents();
//        }

//        private void DeleteContent()
//        {
//            sut.Delete(CreateContentCommand(new DeleteContent()));
//            sut.ClearUncommittedEvents();
//        }

//        protected T CreateContentEvent<T>(T @event) where T : ContentEvent
//        {
//            @event.ContentId = contentId;

//            return CreateEvent(@event);
//        }

//        protected T CreateContentCommand<T>(T command) where T : ContentCommand
//        {
//            command.ContentId = contentId;

//            return CreateCommand(command);
//        }
//    }
//}