abp/framework/test/Volo.Abp.Caching.Tests/Volo/Abp/Caching/DistributedCache_Tests.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Shouldly;
using Volo.Abp.Testing;
using Volo.Abp.Uow;
using Xunit;

namespace Volo.Abp.Caching;

public class DistributedCache_Tests : AbpIntegratedTest<AbpCachingTestModule>
{
    [Fact]
    public async Task Should_Set_Get_And_Remove_Cache_Items()
    {
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheKey = Guid.NewGuid().ToString();
        const string personName = "john nash";

        //Get (not exists yet)
        var cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldBeNull();

        //Set
        cacheItem = new PersonCacheItem(personName);
        await personCache.SetAsync(cacheKey, cacheItem);

        //Get (it should be available now
        cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldNotBeNull();
        cacheItem.Name.ShouldBe(personName);

        //Remove
        await personCache.RemoveAsync(cacheKey);

        //Get (not exists since removed)
        cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldBeNull();
    }

    [Fact]
    public void GetOrAdd()
    {
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheKey = Guid.NewGuid().ToString();
        const string personName = "john nash";

        //Will execute the factory method to create the cache item

        bool factoryExecuted = false;

        var cacheItem = personCache.GetOrAdd(cacheKey,
            () =>
            {
                factoryExecuted = true;
                return new PersonCacheItem(personName);
            });

        factoryExecuted.ShouldBeTrue();
        cacheItem.Name.ShouldBe(personName);

        //This time, it will not execute the factory

        factoryExecuted = false;

        cacheItem = personCache.GetOrAdd(cacheKey,
            () =>
            {
                factoryExecuted = true;
                return new PersonCacheItem(personName);
            });

        factoryExecuted.ShouldBeFalse();
        cacheItem.Name.ShouldBe(personName);
    }

    [Fact]
    public async Task SameClassName_But_DiffNamespace_Should_Not_Use_Same_Cache()
    {
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();
        var otherPersonCache = GetRequiredService<IDistributedCache<Sail.Testing.Caching.PersonCacheItem>>();

        var cacheKey = Guid.NewGuid().ToString();
        const string personName = "john nash";

        //Get (not exists yet)
        var cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldBeNull();

        var cacheItem1 = await otherPersonCache.GetAsync(cacheKey);
        cacheItem1.ShouldBeNull();

        //Set
        cacheItem = new PersonCacheItem(personName);
        await personCache.SetAsync(cacheKey, cacheItem);

        //Get (it should be available now, but otherPersonCache not exists now.
        cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldNotBeNull();
        cacheItem.Name.ShouldBe(personName);

        cacheItem1 = await otherPersonCache.GetAsync(cacheKey);
        cacheItem1.ShouldBeNull();

        //set other person cache
        cacheItem1 = new Sail.Testing.Caching.PersonCacheItem(personName);
        await otherPersonCache.SetAsync(cacheKey, cacheItem1);

        cacheItem1 = await otherPersonCache.GetAsync(cacheKey);
        cacheItem1.ShouldNotBeNull();
        cacheItem1.Name.ShouldBe(personName);

        //Remove
        await personCache.RemoveAsync(cacheKey);


        //Get (not exists since removed)
        cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldBeNull();

        cacheItem1 = await otherPersonCache.GetAsync(cacheKey);
        cacheItem1.ShouldNotBeNull();

    }

    [Fact]
    public async Task Should_Set_Get_And_Remove_Cache_Items_With_Integer_Type_CacheKey()
    {
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem, int>>();

        var cacheKey = 42;
        const string personName = "john nash";

        //Get (not exists yet)
        var cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldBeNull();

        //Set
        cacheItem = new PersonCacheItem(personName);
        await personCache.SetAsync(cacheKey, cacheItem);

        //Get (it should be available now
        cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldNotBeNull();
        cacheItem.Name.ShouldBe(personName);

        //Remove
        await personCache.RemoveAsync(cacheKey);

        //Get (not exists since removed)
        cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldBeNull();
    }

    [Fact]
    public async Task GetOrAddAsync_With_Integer_Type_CacheKey()
    {
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem, int>>();

        var cacheKey = 42;
        const string personName = "john nash";

        //Will execute the factory method to create the cache item

        bool factoryExecuted = false;

        var cacheItem = personCache.GetOrAdd(cacheKey,
            () =>
            {
                factoryExecuted = true;
                return new PersonCacheItem(personName);
            });

        factoryExecuted.ShouldBeTrue();
        cacheItem.Name.ShouldBe(personName);

        //This time, it will not execute the factory

        factoryExecuted = false;

        cacheItem = await personCache.GetOrAddAsync(cacheKey,
            () =>
            {
                factoryExecuted = true;
                return Task.FromResult(new PersonCacheItem(personName));
            });

        factoryExecuted.ShouldBeFalse();
        cacheItem.Name.ShouldBe(personName);
    }

    [Fact]
    public async Task SameClassName_But_DiffNamespace_Should_Not_Use_Same_Cache_With_Integer_CacheKey()
    {
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem, int>>();
        var otherPersonCache = GetRequiredService<IDistributedCache<Sail.Testing.Caching.PersonCacheItem, int>>();


        var cacheKey = 42;
        const string personName = "john nash";

        //Get (not exists yet)
        var cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldBeNull();

        var cacheItem1 = await otherPersonCache.GetAsync(cacheKey);
        cacheItem1.ShouldBeNull();

        //Set
        cacheItem = new PersonCacheItem(personName);
        await personCache.SetAsync(cacheKey, cacheItem);

        //Get (it should be available now, but otherPersonCache not exists now.
        cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldNotBeNull();
        cacheItem.Name.ShouldBe(personName);

        cacheItem1 = await otherPersonCache.GetAsync(cacheKey);
        cacheItem1.ShouldBeNull();

        //set other person cache
        cacheItem1 = new Sail.Testing.Caching.PersonCacheItem(personName);
        await otherPersonCache.SetAsync(cacheKey, cacheItem1);

        cacheItem1 = await otherPersonCache.GetAsync(cacheKey);
        cacheItem1.ShouldNotBeNull();
        cacheItem1.Name.ShouldBe(personName);

        //Remove
        await personCache.RemoveAsync(cacheKey);


        //Get (not exists since removed)
        cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldBeNull();

        cacheItem1 = await otherPersonCache.GetAsync(cacheKey);
        cacheItem1.ShouldNotBeNull();

    }

    [Fact]
    public async Task Should_Set_Get_And_Remove_Cache_Items_With_Object_Type_CacheKey()
    {
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem, ComplexObjectAsCacheKey>>();

        var cacheKey = new ComplexObjectAsCacheKey { Name = "DummyData", Age = 42 };
        const string personName = "john nash";

        //Get (not exists yet)
        var cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldBeNull();

        //Set
        cacheItem = new PersonCacheItem(personName);
        await personCache.SetAsync(cacheKey, cacheItem);

        //Get (it should be available now
        cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldNotBeNull();
        cacheItem.Name.ShouldBe(personName);

        //Remove
        await personCache.RemoveAsync(cacheKey);

        //Get (not exists since removed)
        cacheItem = await personCache.GetAsync(cacheKey);
        cacheItem.ShouldBeNull();
    }

    [Fact]
    public async Task Should_Set_Get_And_Remove_Cache_Items_For_Same_Object_Type_With_Different_CacheKeys()
    {
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem, ComplexObjectAsCacheKey>>();

        var cache1Key = new ComplexObjectAsCacheKey { Name = "John", Age = 42 };
        var cache2Key = new ComplexObjectAsCacheKey { Name = "Jenny", Age = 24 };
        const string personName = "john nash";

        //Get (not exists yet)
        var cacheItem1 = await personCache.GetAsync(cache1Key);
        var cacheItem2 = await personCache.GetAsync(cache2Key);
        cacheItem1.ShouldBeNull();
        cacheItem2.ShouldBeNull();

        //Set
        cacheItem1 = new PersonCacheItem(personName);
        cacheItem2 = new PersonCacheItem(personName);
        await personCache.SetAsync(cache1Key, cacheItem1);
        await personCache.SetAsync(cache2Key, cacheItem2);

        //Get (it should be available now
        cacheItem1 = await personCache.GetAsync(cache1Key);
        cacheItem1.ShouldNotBeNull();
        cacheItem1.Name.ShouldBe(personName);

        cacheItem2 = await personCache.GetAsync(cache2Key);
        cacheItem2.ShouldNotBeNull();
        cacheItem2.Name.ShouldBe(personName);

        //Remove
        await personCache.RemoveAsync(cache1Key);
        await personCache.RemoveAsync(cache2Key);

        //Get (not exists since removed)
        cacheItem1 = await personCache.GetAsync(cache1Key);
        cacheItem1.ShouldBeNull();
        cacheItem2 = await personCache.GetAsync(cache2Key);
        cacheItem2.ShouldBeNull();
    }

    [Fact]
    public async Task Cache_Should_Only_Available_In_Uow_For_GetAsync()
    {
        const string key = "testkey";

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

            var cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldBeNull();

            await personCache.SetAsync(key, new PersonCacheItem("john"), considerUow: true);

            cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldNotBeNull();
            cacheValue.Name.ShouldBe("john");

            cacheValue = await personCache.GetAsync(key, considerUow: false);
            cacheValue.ShouldBeNull();

            uow.OnCompleted(async () =>
            {
                cacheValue = await personCache.GetAsync(key, considerUow: false);
                cacheValue.ShouldNotBeNull();
                cacheValue.Name.ShouldBe("john");
            });

            await uow.CompleteAsync();
        }
    }

    [Fact]
    public async Task Cache_Should_Rollback_With_Uow_For_GetAsync()
    {
        const string key = "testkey";
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheValue = await personCache.GetAsync(key, considerUow: false);
        cacheValue.ShouldBeNull();

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldBeNull();

            await personCache.SetAsync(key, new PersonCacheItem("john"), considerUow: true);

            cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldNotBeNull();
            cacheValue.Name.ShouldBe("john");

            cacheValue = await personCache.GetAsync(key, considerUow: false);
            cacheValue.ShouldBeNull();
        }

        cacheValue = await personCache.GetAsync(key, considerUow: false);
        cacheValue.ShouldBeNull();
    }

    [Fact]
    public async Task Cache_Should_Only_Available_In_Uow_For_GetOrAddAsync()
    {
        const string key = "testkey";

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

            var cacheValue = await personCache.GetOrAddAsync(key, () => Task.FromResult(new PersonCacheItem("john")), considerUow: true);
            cacheValue.ShouldNotBeNull();
            cacheValue.Name.ShouldBe("john");

            cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldNotBeNull();
            cacheValue.Name.ShouldBe("john");

            cacheValue = await personCache.GetAsync(key, considerUow: false);
            cacheValue.ShouldBeNull();

            uow.OnCompleted(async () =>
            {
                cacheValue = await personCache.GetAsync(key, considerUow: false);
                cacheValue.ShouldNotBeNull();
                cacheValue.Name.ShouldBe("john");
            });

            await uow.CompleteAsync();
        }
    }

    [Fact]
    public async Task Cache_Should_Rollback_With_Uow_For_GetOrAddAsync()
    {
        const string key = "testkey";
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheValue = await personCache.GetAsync(key, considerUow: false);
        cacheValue.ShouldBeNull();

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            cacheValue = await personCache.GetOrAddAsync(key, () => Task.FromResult(new PersonCacheItem("john")), considerUow: true);
            cacheValue.ShouldNotBeNull();
            cacheValue.Name.ShouldBe("john");

            cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldNotBeNull();
            cacheValue.Name.ShouldBe("john");

            cacheValue = await personCache.GetAsync(key, considerUow: false);
            cacheValue.ShouldBeNull();
        }

        cacheValue = await personCache.GetAsync(key, considerUow: false);
        cacheValue.ShouldBeNull();
    }

    [Fact]
    public async Task Cache_Should_Only_Available_In_Uow_For_SetAsync()
    {
        const string key = "testkey";

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

            await personCache.SetAsync(key, new PersonCacheItem("john"), considerUow: true);

            var cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldNotBeNull();
            cacheValue.Name.ShouldBe("john");

            cacheValue = await personCache.GetAsync(key, considerUow: false);
            cacheValue.ShouldBeNull();

            uow.OnCompleted(async () =>
            {
                cacheValue = await personCache.GetAsync(key, considerUow: false);
                cacheValue.ShouldNotBeNull();
                cacheValue.Name.ShouldBe("john");
            });

            await uow.CompleteAsync();
        }
    }

    [Fact]
    public async Task Cache_Should_Rollback_With_Uow_For_SetAsync()
    {
        const string key = "testkey";
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheValue = await personCache.GetAsync(key, considerUow: false);
        cacheValue.ShouldBeNull();

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            await personCache.SetAsync(key, new PersonCacheItem("john"), considerUow: true);

            cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldNotBeNull();
            cacheValue.Name.ShouldBe("john");

            cacheValue = await personCache.GetAsync(key, considerUow: false);
            cacheValue.ShouldBeNull();
        }

        cacheValue = await personCache.GetAsync(key, considerUow: false);
        cacheValue.ShouldBeNull();
    }

    [Fact]
    public async Task Cache_Should_Only_Available_In_Uow_For_RemoveAsync()
    {
        const string key = "testkey";

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

            await personCache.SetAsync(key, new PersonCacheItem("john"), considerUow: true);

            var cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldNotBeNull();
            cacheValue.Name.ShouldBe("john");

            await personCache.RemoveAsync(key, considerUow: true);

            cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldBeNull();

            uow.OnCompleted(async () =>
            {
                cacheValue = await personCache.GetAsync(key, considerUow: false);
                cacheValue.ShouldBeNull();
            });

            await uow.CompleteAsync();
        }
    }

    [Fact]
    public async Task Cache_Should_Rollback_With_Uow_For_RemoveAsync()
    {
        const string key = "testkey";
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheValue = await personCache.GetAsync(key, considerUow: false);
        cacheValue.ShouldBeNull();

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            await personCache.SetAsync(key, new PersonCacheItem("john"), considerUow: true);

            cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldNotBeNull();
            cacheValue.Name.ShouldBe("john");

            await personCache.RemoveAsync(key, considerUow: true);

            cacheValue = await personCache.GetAsync(key, considerUow: true);
            cacheValue.ShouldBeNull();
        }

        cacheValue = await personCache.GetAsync(key, considerUow: false);
        cacheValue.ShouldBeNull();
    }

    [Fact]
    public async Task Cache_Should_Only_Available_In_Uow_For_GetManyAsync()
    {
        var testkey = "testkey";
        var testkey2 = "testkey2";
        var testKeys = new[] { testkey, testkey2 };

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

            var cacheValue = await personCache.GetManyAsync(testKeys, considerUow: true);
            cacheValue.Where(x => x.Value != null).ShouldBeEmpty();

            await personCache.SetManyAsync(new List<KeyValuePair<string, PersonCacheItem>>
               {
                   new KeyValuePair<string, PersonCacheItem>(testkey, new PersonCacheItem("john")),
                   new KeyValuePair<string, PersonCacheItem>(testkey2, new PersonCacheItem("jack"))
               }, considerUow: true);

            cacheValue = await personCache.GetManyAsync(testKeys, considerUow: true);
            cacheValue.Where(x => x.Value != null).ShouldNotBeEmpty();
            cacheValue.ShouldContain(x => x.Value.Name == "john" || x.Value.Name == "jack");

            cacheValue = await personCache.GetManyAsync(testKeys, considerUow: false);
            cacheValue.Where(x => x.Value != null).ShouldBeEmpty();

            uow.OnCompleted(async () =>
            {
                cacheValue = await personCache.GetManyAsync(testKeys, considerUow: false);
                cacheValue.ShouldNotBeEmpty();
                cacheValue.ShouldContain(x => x.Value.Name == "john" || x.Value.Name == "jack");
            });

            await uow.CompleteAsync();
        }
    }

    [Fact]
    public async Task Cache_Should_Rollback_With_Uow_For_GetManyAsync()
    {
        var testkey = "testkey";
        var testkey2 = "testkey2";
        var testKeys = new[] { testkey, testkey2 };

        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheValue = await personCache.GetManyAsync(testKeys, considerUow: false);
        cacheValue.Where(x => x.Value != null).ShouldBeEmpty();

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            cacheValue = await personCache.GetManyAsync(testKeys, considerUow: true);
            cacheValue.Where(x => x.Value != null).ShouldBeEmpty();

            await personCache.SetManyAsync(new List<KeyValuePair<string, PersonCacheItem>>
                {
                    new KeyValuePair<string, PersonCacheItem>(testkey, new PersonCacheItem("john")),
                    new KeyValuePair<string, PersonCacheItem>(testkey2, new PersonCacheItem("jack"))
                }, considerUow: true);

            cacheValue = await personCache.GetManyAsync(testKeys, considerUow: true);
            cacheValue.Where(x => x.Value != null).ShouldNotBeEmpty();
            cacheValue.ShouldContain(x => x.Value.Name == "john" || x.Value.Name == "jack");

            cacheValue = await personCache.GetManyAsync(testKeys, considerUow: false);
            cacheValue.Where(x => x.Value != null).ShouldBeEmpty();
        }

        cacheValue = await personCache.GetManyAsync(testKeys, considerUow: false);
        cacheValue.Where(x => x.Value != null).ShouldBeEmpty();
    }


    [Fact]
    public async Task Cache_Should_Only_Available_In_Uow_For_SetManyAsync()
    {
        var testkey = "testkey";
        var testkey2 = "testkey2";
        var testKeys = new[] { testkey, testkey2 };

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

            await personCache.SetManyAsync(new List<KeyValuePair<string, PersonCacheItem>>
                {
                    new KeyValuePair<string, PersonCacheItem>(testkey, new PersonCacheItem("john")),
                    new KeyValuePair<string, PersonCacheItem>(testkey, new PersonCacheItem("jack"))
                }, considerUow: true);

            var cacheValue = await personCache.GetManyAsync(testKeys, considerUow: true);
            cacheValue.Where(x => x.Value != null).ShouldNotBeEmpty();
            cacheValue.ShouldContain(x => x.Value.Name == "john" || x.Value.Name == "jack");

            cacheValue = await personCache.GetManyAsync(testKeys, considerUow: false);
            cacheValue.Where(x => x.Value != null).ShouldBeEmpty();

            uow.OnCompleted(async () =>
            {
                var cacheValue = await personCache.GetManyAsync(testKeys, considerUow: false);
                cacheValue.Where(x => x.Value != null).ShouldNotBeEmpty();
                cacheValue.ShouldContain(x => x.Value.Name == "john" || x.Value.Name == "jack");
            });

            await uow.CompleteAsync();
        }
    }

    [Fact]
    public async Task Cache_Should_Rollback_With_Uow_For_SetManyAsync()
    {
        var testkey = "testkey";
        var testkey2 = "testkey2";
        var testKeys = new[] { testkey, testkey2 };

        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheValue = await personCache.GetManyAsync(testKeys, considerUow: false);
        cacheValue.Where(x => x.Value != null).ShouldBeEmpty();

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            await personCache.SetManyAsync(new List<KeyValuePair<string, PersonCacheItem>>
                {
                    new KeyValuePair<string, PersonCacheItem>(testkey, new PersonCacheItem("john")),
                    new KeyValuePair<string, PersonCacheItem>(testkey, new PersonCacheItem("jack"))
                }, considerUow: true);

            cacheValue = await personCache.GetManyAsync(testKeys, considerUow: true);
            cacheValue.Where(x => x.Value != null).ShouldNotBeEmpty();
            cacheValue.ShouldContain(x => x.Value.Name == "john" || x.Value.Name == "jack");

            cacheValue = await personCache.GetManyAsync(testKeys, considerUow: false);
            cacheValue.Where(x => x.Value != null).ShouldBeEmpty();
        }

        cacheValue = await personCache.GetManyAsync(testKeys, considerUow: false);
        cacheValue.Where(x => x.Value != null).ShouldBeEmpty();
    }


    [Fact]
    public async Task Should_Set_And_Get_Multiple_Items_Async()
    {
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        await personCache.SetManyAsync(new[]
        {
                new KeyValuePair<string, PersonCacheItem>("john", new PersonCacheItem("John Nash")),
                new KeyValuePair<string, PersonCacheItem>("thomas", new PersonCacheItem("Thomas Moore"))
            });

        var cacheItems = await personCache.GetManyAsync(new[]
        {
                "john",
                "thomas",
                "baris" //doesn't exist
            });

        cacheItems.Length.ShouldBe(3);
        cacheItems[0].Key.ShouldBe("john");
        cacheItems[0].Value.Name.ShouldBe("John Nash");
        cacheItems[1].Key.ShouldBe("thomas");
        cacheItems[1].Value.Name.ShouldBe("Thomas Moore");
        cacheItems[2].Key.ShouldBe("baris");
        cacheItems[2].Value.ShouldBeNull();

        (await personCache.GetAsync("john")).Name.ShouldBe("John Nash");
        (await personCache.GetAsync("baris")).ShouldBeNull();
    }

    [Fact]
    public async Task Should_Get_And_Add_Multiple_Items_Async()
    {
        var testkey = "testkey";
        var testkey2 = "testkey2";

        var testkey3 = new[] { testkey, testkey2 };
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        await personCache.SetAsync(testkey, new PersonCacheItem("john"));

        var cacheValue = await personCache.GetManyAsync(testkey3);
        cacheValue.Length.ShouldBe(2);
        cacheValue[0].Value.Name.ShouldBe("john");
        cacheValue[1].Value.ShouldBeNull();

        cacheValue = await personCache.GetOrAddManyAsync(testkey3, (missingKeys) =>
        {
            var missingKeyArray = missingKeys.ToArray();
            missingKeyArray.Length.ShouldBe(1);
            missingKeyArray[0].ShouldBe(testkey2);

            return Task.FromResult(new List<KeyValuePair<string, PersonCacheItem>>
            {
                    new(testkey2, new PersonCacheItem("jack"))
            });
        });

        cacheValue.Length.ShouldBe(2);
        cacheValue[0].Value.Name.ShouldBe("john");
        cacheValue[1].Value.Name.ShouldBe("jack");

        cacheValue = await personCache.GetManyAsync(testkey3);
        cacheValue.Length.ShouldBe(2);
        cacheValue[0].Value.Name.ShouldBe("john");
        cacheValue[1].Value.Name.ShouldBe("jack");
    }

    [Fact]
    public async Task Cache_Should_Only_Available_In_Uow_For_GetOrAddManyAsync()
    {
        var testkey = "testkey";
        var testkey2 = "testkey2";

        var testkey3 = new[] { testkey, testkey2 };

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

            var cacheValue = await personCache.GetOrAddManyAsync(testkey3, (missingKeys) => Task.FromResult(new List<KeyValuePair<string, PersonCacheItem>>
                {
                    new(testkey, new PersonCacheItem("john")),
                    new(testkey2, new PersonCacheItem("jack")),
                }), considerUow: true);

            cacheValue.Length.ShouldBe(2);
            cacheValue[0].Value.Name.ShouldBe("john");
            cacheValue[1].Value.Name.ShouldBe("jack");

            cacheValue = await personCache.GetManyAsync(testkey3, considerUow: true);
            cacheValue.Length.ShouldBe(2);
            cacheValue[0].Value.Name.ShouldBe("john");
            cacheValue[1].Value.Name.ShouldBe("jack");

            cacheValue = await personCache.GetManyAsync(testkey3, considerUow: false);
            cacheValue.Length.ShouldBe(2);
            cacheValue[0].Value.ShouldBeNull();
            cacheValue[1].Value.ShouldBeNull();

            uow.OnCompleted(async () =>
            {
                cacheValue = await personCache.GetManyAsync(testkey3, considerUow: false);
                cacheValue.ShouldNotBeNull();
                cacheValue[0].Value.Name.ShouldBe("john");
                cacheValue[1].Value.Name.ShouldBe("jack");
            });

            await uow.CompleteAsync();
        }
    }

    [Fact]
    public async Task Cache_Should_Rollback_With_Uow_For_GetOrAddManyAsync()
    {
        var testkey = "testkey";
        var testkey2 = "testkey2";

        var testkey3 = new[] { testkey, testkey2 };

        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheValue = await personCache.GetManyAsync(testkey3, considerUow: false);
        cacheValue.Length.ShouldBe(2);
        cacheValue[0].Value.ShouldBeNull();
        cacheValue[1].Value.ShouldBeNull();

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            cacheValue = await personCache.GetOrAddManyAsync(testkey3, (missingKeys) => Task.FromResult(new List<KeyValuePair<string, PersonCacheItem>>
                {
                    new(testkey, new PersonCacheItem("john")),
                    new(testkey2, new PersonCacheItem("jack")),
                }), considerUow: true);

            cacheValue.Length.ShouldBe(2);
            cacheValue[0].Value.Name.ShouldBe("john");
            cacheValue[1].Value.Name.ShouldBe("jack");

            cacheValue = await personCache.GetManyAsync(testkey3, considerUow: true);
            cacheValue.Length.ShouldBe(2);
            cacheValue[0].Value.Name.ShouldBe("john");
            cacheValue[1].Value.Name.ShouldBe("jack");

            cacheValue = await personCache.GetManyAsync(testkey3, considerUow: false);
            cacheValue.Length.ShouldBe(2);
            cacheValue[0].Value.ShouldBeNull();
            cacheValue[1].Value.ShouldBeNull();
        }

        cacheValue = await personCache.GetManyAsync(testkey3, considerUow: false);
        cacheValue.Length.ShouldBe(2);
        cacheValue[0].Value.ShouldBeNull();
        cacheValue[1].Value.ShouldBeNull();
    }

    [Fact]
    public async Task Should_Remove_Multiple_Items_Async()
    {
        var testkey = "testkey";
        var testkey2 = "testkey2";
        var testkey3 = new[] { testkey, testkey2 };

        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        await personCache.SetManyAsync(new List<KeyValuePair<string, PersonCacheItem>>
            {
                new(testkey, new PersonCacheItem("john")),
                new(testkey2, new PersonCacheItem("jack"))
            });

        await personCache.RemoveManyAsync(testkey3);

        var cacheValue = await personCache.GetManyAsync(testkey3);
        cacheValue.Length.ShouldBe(2);
        cacheValue[0].Value.ShouldBeNull();
        cacheValue[1].Value.ShouldBeNull();
    }

    [Fact]
    public async Task Cache_Should_Only_Available_In_Uow_For_RemoveManyAsync()
    {
        var testkey = "testkey";
        var testkey2 = "testkey2";
        var testkey3 = new[] { testkey, testkey2 };
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheValue = await personCache.GetManyAsync(testkey3, considerUow: false);
        cacheValue.Length.ShouldBe(2);
        cacheValue[0].Value.ShouldBeNull();
        cacheValue[1].Value.ShouldBeNull();

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            await personCache.SetManyAsync(new List<KeyValuePair<string, PersonCacheItem>>
                {
                    new(testkey, new PersonCacheItem("john")),
                    new(testkey2, new PersonCacheItem("jack"))
                });

            cacheValue = await personCache.GetManyAsync(testkey3, considerUow: true);
            cacheValue.Length.ShouldBe(2);
            cacheValue[0].Value.Name.ShouldBe("john");
            cacheValue[1].Value.Name.ShouldBe("jack");

            await personCache.RemoveManyAsync(testkey3, considerUow: true);

            cacheValue = await personCache.GetManyAsync(testkey3, considerUow: false);
            cacheValue.Length.ShouldBe(2);
            cacheValue[0].Value.Name.ShouldBe("john");
            cacheValue[1].Value.Name.ShouldBe("jack");

            uow.OnCompleted(async () =>
            {
                cacheValue = await personCache.GetManyAsync(testkey3, considerUow: false);
                cacheValue.ShouldNotBeNull();
                cacheValue[0].Value.ShouldBeNull();
                cacheValue[1].Value.ShouldBeNull();
            });

            await uow.CompleteAsync();
        }

    }

    [Fact]
    public async Task Cache_Should_Rollback_With_Uow_For_RemoveManyAsync()
    {
        var testkey = "testkey";
        var testkey2 = "testkey2";
        var testkey3 = new[] { testkey, testkey2 };
        var personCache = GetRequiredService<IDistributedCache<PersonCacheItem>>();

        var cacheValue = await personCache.GetManyAsync(testkey3, considerUow: false);
        cacheValue.Length.ShouldBe(2);
        cacheValue[0].Value.ShouldBeNull();
        cacheValue[1].Value.ShouldBeNull();

        using (var uow = GetRequiredService<IUnitOfWorkManager>().Begin())
        {
            await personCache.SetManyAsync(new List<KeyValuePair<string, PersonCacheItem>>
                {
                    new(testkey, new PersonCacheItem("john")),
                    new(testkey2, new PersonCacheItem("jack"))
                }, considerUow: true);

            cacheValue = await personCache.GetManyAsync(testkey3, considerUow: true);
            cacheValue.Length.ShouldBe(2);
            cacheValue[0].Value.Name.ShouldBe("john");
            cacheValue[1].Value.Name.ShouldBe("jack");

            await personCache.RemoveManyAsync(testkey3, considerUow: true);

            cacheValue = await personCache.GetManyAsync(testkey3, considerUow: true);
            cacheValue.Length.ShouldBe(2);
            cacheValue[0].Value.ShouldBeNull();
            cacheValue[1].Value.ShouldBeNull();
        }

        cacheValue = await personCache.GetManyAsync(testkey3, considerUow: true);
        cacheValue.Length.ShouldBe(2);
        cacheValue[0].Value.ShouldBeNull();
        cacheValue[1].Value.ShouldBeNull();
    }

    [Fact]
    public async Task Should_Get_Same_Cache_Set_When_Resolve_With_Or_Without_Key()
    {
        var cache1 = GetRequiredService<IDistributedCache<PersonCacheItem>>();
        var cache2 = GetRequiredService<IDistributedCache<PersonCacheItem, string>>();

        cache1.InternalCache.ShouldBe(cache2);

        await cache1.SetAsync("john", new PersonCacheItem("John Doe"));

        var item1 = await cache1.GetAsync("john");
        item1.Name.ShouldBe("John Doe");

        var item2 = await cache2.GetAsync("john");
        item2.Name.ShouldBe("John Doe");
    }
}