squidex/backend/tests/Squidex.Domain.Apps.Entities.Tests/Apps/Indexes/AppsIndexIntegrationTests.cs

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

using System;
using System.Linq;
using System.Threading.Tasks;
using FakeItEasy;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Orleans;
using Orleans.Hosting;
using Orleans.TestingHost;
using Squidex.Caching;
using Squidex.Domain.Apps.Core.Apps;
using Squidex.Domain.Apps.Entities.Apps.Commands;
using Squidex.Domain.Apps.Entities.Apps.DomainObject;
using Squidex.Infrastructure;
using Squidex.Infrastructure.Commands;
using Squidex.Infrastructure.Orleans;
using Xunit;

namespace Squidex.Domain.Apps.Entities.Apps.Indexes
{
    [Trait("Category", "Dependencies")]
    public class AppsIndexIntegrationTests
    {
        public class GrainEnvironment
        {
            private AppContributors contributors = AppContributors.Empty;

            public IGrainFactory GrainFactory { get; } = A.Fake<IGrainFactory>();

            public NamedId<DomainId> AppId { get; } = NamedId.Of(DomainId.NewGuid(), "my-app");

            public GrainEnvironment()
            {
                var indexGrain = A.Fake<IAppsByNameIndexGrain>();

                A.CallTo(() => indexGrain.GetIdAsync(AppId.Name))
                    .Returns(AppId.Id);

                var appGrain = A.Fake<IAppGrain>();

                A.CallTo(() => appGrain.GetStateAsync())
                    .ReturnsLazily(() => CreateEntity().AsJ());

                A.CallTo(() => GrainFactory.GetGrain<IAppGrain>(AppId.Id.ToString(), null))
                    .Returns(appGrain);

                A.CallTo(() => GrainFactory.GetGrain<IAppsByNameIndexGrain>(SingleGrain.Id, null))
                    .Returns(indexGrain);
            }

            public void HandleCommand(AssignContributor contributor)
            {
                contributors = contributors.Assign(contributor.ContributorId, Role.Developer);
            }

            public void VerifyGrainAccess(int count)
            {
                A.CallTo(() => GrainFactory.GetGrain<IAppGrain>(AppId.Id.ToString(), null))
                    .MustHaveHappenedANumberOfTimesMatching(x => x == count);
            }

            private IAppEntity CreateEntity()
            {
                var appEntity = A.Fake<IAppEntity>();

                A.CallTo(() => appEntity.Id)
                    .Returns(AppId.Id);

                A.CallTo(() => appEntity.Name)
                    .Returns(AppId.Name);

                A.CallTo(() => appEntity.Contributors)
                    .Returns(new AppContributors(contributors.ToDictionary()));

                return appEntity;
            }
        }

        private sealed class Configurator : ISiloConfigurator
        {
            public void Configure(ISiloBuilder siloBuilder)
            {
                siloBuilder.AddOrleansPubSub();
            }
        }

        [Theory]
        [InlineData(3, 100, 300, false)]
        [InlineData(3, 100, 102, true)]
        public async Task Should_distribute_and_cache_domain_objects(short numSilos, int numRuns, int expectedCounts, bool shouldBreak)
        {
            var env = new GrainEnvironment();

            var cluster =
                new TestClusterBuilder(numSilos)
                    .AddSiloBuilderConfigurator<Configurator>()
                    .Build();

            await cluster.DeployAsync();

            try
            {
                var indexes =
                    cluster.Silos.OfType<InProcessSiloHandle>()
                        .Select(x =>
                        {
                            var pubSub =
                                shouldBreak ?
                                    A.Fake<IPubSub>() :
                                    x.SiloHost.Services.GetRequiredService<IPubSub>();

                            var cache =
                                new ReplicatedCache(
                                    new MemoryCache(Options.Create(new MemoryCacheOptions())),
                                    pubSub,
                                    Options.Create(new ReplicatedCacheOptions { Enable = true }));

                            return new AppsIndex(env.GrainFactory, cache);
                        }).ToArray();

                var appId = env.AppId;

                var random = new Random();

                for (var i = 0; i < numRuns; i++)
                {
                    var contributorId = Guid.NewGuid().ToString();
                    var contributorCommand = new AssignContributor { ContributorId = contributorId, AppId = appId };

                    var commandContext = new CommandContext(contributorCommand, A.Fake<ICommandBus>());

                    var randomIndex = indexes[random.Next(numSilos)];

                    await randomIndex.HandleAsync(commandContext, x =>
                    {
                        if (x.Command is AssignContributor command)
                        {
                            env.HandleCommand(command);
                        }

                        x.Complete(true);

                        return Task.CompletedTask;
                    });

                    foreach (var index in indexes)
                    {
                        var appById = await index.GetAppAsync(appId.Id, true);
                        var appByName = await index.GetAppByNameAsync(appId.Name, true);

                        if (index == randomIndex || !shouldBreak || i == 0)
                        {
                            Assert.True(appById?.Contributors.ContainsKey(contributorId));
                            Assert.True(appByName?.Contributors.ContainsKey(contributorId));
                        }
                        else
                        {
                            Assert.False(appById?.Contributors.ContainsKey(contributorId));
                            Assert.False(appByName?.Contributors.ContainsKey(contributorId));
                        }
                    }
                }

                env.VerifyGrainAccess(expectedCounts);
            }
            finally
            {
                await Task.WhenAny(Task.Delay(2000), cluster.StopAllSilosAsync());
            }
        }
    }
}