MappedResultsStorageActionsTests.cs - Copyright (c) Hiberna…

/ToMigrate/Raven.Tests/Storage/Voron/MappedResultsStorageActionsTests.cs

https://github.com/fitzchak/ravendb · C# · 1066 lines · 834 code · 226 blank · 6 comment · 2 complexity · 3f190c39c7b8f70db8478594e914d76b MD5 · raw file

// -----------------------------------------------------------------------

//  <copyright file="MappedResultsStorageActionsTests.cs" company="Hibernating Rhinos LTD">

//      Copyright (c) Hibernating Rhinos LTD. All rights reserved.

//  </copyright>

// -----------------------------------------------------------------------

using System.Collections.Generic;

using System.Linq;

using System.Threading;

using Raven.Abstractions.Data;

using Raven.Database.Indexing;

using Raven.Database.Storage;

using Raven.Json.Linq;

using Raven.Tests.Common;

using Sparrow.Collections;

using Xunit;

using Xunit.Extensions;



namespace Raven.Tests.Storage.Voron

{

    [Trait("VoronTest", "StorageActionsTests")]

    public class MappedResultsStorageActionsTests : TransactionalStorageTestBase

    {

        [Theory]

        [PropertyData("Storages")]

        public void IncrementReduceKeyCounterWithNegativeValues(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 11));



                storage.Batch(

                    accessor =>

                    {

                        var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                        var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();



                        Assert.Equal(0, reduceKeysAndTypes.Count);

                        Assert.Equal(1, keyStats.Count);

                    });



                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 0));



                storage.Batch(

                    accessor =>

                    {

                        var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();



                        Assert.Equal(1, keyStats.Count);



                        var k1 = keyStats[0];

                        Assert.Equal(11, k1.Count);

                    });



                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", -1));



                storage.Batch(

                    accessor =>

                    {

                        var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();



                        Assert.Equal(1, keyStats.Count);



                        var k1 = keyStats[0];

                        Assert.Equal(10, k1.Count);

                    });



                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", -10));



                storage.Batch(

                    accessor =>

                    {

                        var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();



                        //the reduce key counter for "reduceKey1" will be removed

                        Assert.Equal(0, keyStats.Count);

                    });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void IncrementReduceKeyCounter(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 7));



                storage.Batch(accessor =>

                {

                    var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();

                    Assert.Equal(1, keyStats.Count);



                    var k1 = keyStats[0];

                    Assert.Equal("reduceKey1", k1.Key);

                    Assert.Equal(7, k1.Count);

                });



                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 3));



                storage.Batch(accessor =>

                {

                    var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();

                    Assert.Equal(1, keyStats.Count);



                    var k1 = keyStats[0];

                    Assert.Equal("reduceKey1", k1.Key);

                    Assert.Equal(10, k1.Count);

                });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void GetReduceKeysAndTypes(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor => Assert.Equal(0, accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).Count()));



                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 2));

                storage.Batch(accessor => accessor.MapReduce.UpdatePerformedReduceType(303, "reduceKey1", ReduceType.SingleStep));

                storage.Batch(accessor => Assert.Equal(1, accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).Count()));



                storage.Batch(accessor => accessor.MapReduce.UpdatePerformedReduceType(303, "reduceKey1", ReduceType.SingleStep));

                storage.Batch(accessor => Assert.Equal(1, accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).Count()));



                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey2", 2));

                storage.Batch(accessor => accessor.MapReduce.UpdatePerformedReduceType(303, "reduceKey2", ReduceType.SingleStep));

                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey3", 2));

                storage.Batch(accessor => accessor.MapReduce.UpdatePerformedReduceType(303, "reduceKey3", ReduceType.SingleStep));

                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(404, "reduceKey4", 2));

                storage.Batch(accessor => accessor.MapReduce.UpdatePerformedReduceType(404, "reduceKey4", ReduceType.MultiStep));

                storage.Batch(accessor => Assert.Equal(3, accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).Count()));



                if (requestedStorage == "esent")

                {

                    storage.Batch(accessor => accessor.MapReduce.PutMappedResult(303, "doc1", "reduceKey1", new RavenJObject()));

                    storage.Batch(accessor => accessor.MapReduce.PutMappedResult(303, "doc2", "reduceKey1", new RavenJObject()));

                    storage.Batch(accessor => accessor.MapReduce.PutMappedResult(303, "doc3", "reduceKey1", new RavenJObject()));

                    storage.Batch(accessor => accessor.MapReduce.PutMappedResult(303, "doc4", "reduceKey1", new RavenJObject()));

                    storage.Batch(accessor => accessor.MapReduce.PutMappedResult(303, "doc5", "reduceKey1", new RavenJObject()));

                }



                storage.Batch(accessor =>

                {

                    var reduceKeyAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 1).ToList();

                    Assert.Equal(1, reduceKeyAndTypes.Count);

                    var k1 = reduceKeyAndTypes[0];



                    reduceKeyAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 1, 1).ToList();

                    Assert.Equal(1, reduceKeyAndTypes.Count);

                    var k2 = reduceKeyAndTypes[0];



                    reduceKeyAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 2, 1).ToList();

                    Assert.Equal(1, reduceKeyAndTypes.Count);

                    var k3 = reduceKeyAndTypes[0];



                    Assert.NotEqual(k1.ReduceKey, k2.ReduceKey);

                    Assert.NotEqual(k1.ReduceKey, k3.ReduceKey);

                    Assert.NotEqual(k2.ReduceKey, k3.ReduceKey);



                    reduceKeyAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 1, 2).ToList();

                    Assert.Equal(2, reduceKeyAndTypes.Count);

                    Assert.Equal(k2.ReduceKey, reduceKeyAndTypes[0].ReduceKey);

                    Assert.Equal(k3.ReduceKey, reduceKeyAndTypes[1].ReduceKey);



                    reduceKeyAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 2, 2).ToList();

                    Assert.Equal(1, reduceKeyAndTypes.Count);

                    Assert.Equal(k3.ReduceKey, reduceKeyAndTypes[0].ReduceKey);



                    reduceKeyAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 5).ToList();

                    Assert.Equal(3, reduceKeyAndTypes.Count);

                    Assert.Equal(k1.ReduceKey, reduceKeyAndTypes[0].ReduceKey);

                    Assert.Equal(k2.ReduceKey, reduceKeyAndTypes[1].ReduceKey);

                    Assert.Equal(k3.ReduceKey, reduceKeyAndTypes[2].ReduceKey);



                    reduceKeyAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 5, 55).ToList();

                    Assert.Equal(0, reduceKeyAndTypes.Count);



                    reduceKeyAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(404, 0, 10).ToList();

                    Assert.Equal(1, reduceKeyAndTypes.Count);

                    Assert.Equal("reduceKey4", reduceKeyAndTypes[0].ReduceKey);

                });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void GetKeyStats(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor => Assert.Equal(0, accessor.MapReduce.GetKeysStats(303, 0, 10).Count()));



                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 7));

                storage.Batch(accessor => Assert.Equal(1, accessor.MapReduce.GetKeysStats(303, 0, 10).Count()));



                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 7));

                storage.Batch(accessor => Assert.Equal(1, accessor.MapReduce.GetKeysStats(303, 0, 10).Count()));



                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey2", 7));

                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey3", 7));

                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(404, "reduceKey1", 7));

                storage.Batch(accessor => Assert.Equal(3, accessor.MapReduce.GetKeysStats(303, 0, 10).Count()));



                storage.Batch(accessor =>

                {

                    var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 1).ToList();

                    Assert.Equal(1, keyStats.Count);

                    var k1 = keyStats[0];



                    keyStats = accessor.MapReduce.GetKeysStats(303, 1, 1).ToList();

                    Assert.Equal(1, keyStats.Count);

                    var k2 = keyStats[0];



                    keyStats = accessor.MapReduce.GetKeysStats(303, 2, 1).ToList();

                    Assert.Equal(1, keyStats.Count);

                    var k3 = keyStats[0];



                    Assert.NotEqual(k1.Key, k2.Key);

                    Assert.NotEqual(k1.Key, k3.Key);

                    Assert.NotEqual(k2.Key, k3.Key);



                    keyStats = accessor.MapReduce.GetKeysStats(303, 1, 2).ToList();

                    Assert.Equal(2, keyStats.Count);

                    Assert.Equal(k2.Key, keyStats[0].Key);

                    Assert.Equal(k3.Key, keyStats[1].Key);



                    keyStats = accessor.MapReduce.GetKeysStats(303, 2, 2).ToList();

                    Assert.Equal(1, keyStats.Count);

                    Assert.Equal(k3.Key, keyStats[0].Key);



                    keyStats = accessor.MapReduce.GetKeysStats(303, 0, 5).ToList();

                    Assert.Equal(3, keyStats.Count);

                    Assert.Equal(k1.Key, keyStats[0].Key);

                    Assert.Equal(k2.Key, keyStats[1].Key);

                    Assert.Equal(k3.Key, keyStats[2].Key);



                    keyStats = accessor.MapReduce.GetKeysStats(303, 5, 55).ToList();

                    Assert.Equal(0, keyStats.Count);



                    keyStats = accessor.MapReduce.GetKeysStats(404, 0, 10).ToList();

                    Assert.Equal(1, keyStats.Count);

                    Assert.Equal("reduceKey1", keyStats[0].Key);

                });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void UpdatePerformedReduceType(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 5));

                storage.Batch(accessor => accessor.MapReduce.UpdatePerformedReduceType(303, "reduceKey1", ReduceType.None));



                storage.Batch(

                    accessor =>

                    {

                        var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();

                        Assert.Equal(1, keyStats.Count);



                        var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                        Assert.Equal(1, reduceKeysAndTypes.Count);

                        Assert.Equal("reduceKey1", reduceKeysAndTypes[0].ReduceKey);

                        Assert.Equal(ReduceType.None, reduceKeysAndTypes[0].OperationTypeToPerform);

                    });



                storage.Batch(accessor => accessor.MapReduce.UpdatePerformedReduceType(303, "reduceKey1", ReduceType.SingleStep));



                storage.Batch(

                    accessor =>

                    {

                        var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();

                        Assert.Equal(1, keyStats.Count);



                        var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                        Assert.Equal(1, reduceKeysAndTypes.Count);

                        Assert.Equal("reduceKey1", reduceKeysAndTypes[0].ReduceKey);

                        Assert.Equal(ReduceType.SingleStep, reduceKeysAndTypes[0].OperationTypeToPerform);

                    });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void IncrementReduceKeyCounterDoesNotInterfereWithUpdatePerformedReduceType(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 5));

                storage.Batch(accessor => accessor.MapReduce.UpdatePerformedReduceType(303, "reduceKey1", ReduceType.MultiStep));



                storage.Batch(

                    accessor =>

                    {

                        var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                        var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();



                        Assert.Equal(1, reduceKeysAndTypes.Count);

                        Assert.Equal("reduceKey1", reduceKeysAndTypes[0].ReduceKey);

                        Assert.Equal(ReduceType.MultiStep, reduceKeysAndTypes[0].OperationTypeToPerform);



                        Assert.Equal(1, keyStats.Count);

                        Assert.Equal("reduceKey1", keyStats[0].Key);

                        Assert.Equal(5, keyStats[0].Count);

                    });



                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(404, "reduceKey2", 5));

                storage.Batch(accessor => accessor.MapReduce.UpdatePerformedReduceType(404, "reduceKey2", ReduceType.MultiStep));



                storage.Batch(

                    accessor =>

                    {

                        var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(404, 0, 10).ToList();

                        var keyStats = accessor.MapReduce.GetKeysStats(404, 0, 10).ToList();



                        Assert.Equal(1, reduceKeysAndTypes.Count);

                        Assert.Equal("reduceKey2", reduceKeysAndTypes[0].ReduceKey);

                        Assert.Equal(ReduceType.MultiStep, reduceKeysAndTypes[0].OperationTypeToPerform);



                        Assert.Equal(1, keyStats.Count);

                        Assert.Equal("reduceKey2", keyStats[0].Key);

                        Assert.Equal(5, keyStats[0].Count);

                    });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void PutMappedResult(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(x => x.MapReduce.PutMappedResult(303, "doc1", "reduceKey1", new RavenJObject { { "data", "data1" } }));



                storage.Batch(x =>

                {

                    var results = x.MapReduce.GetMappedResults(303, new HashSet<string> { "reduceKey1" }, true, 100, new HashSet<string>(), CancellationToken.None);



                    Assert.Equal(1, results.Count);



                    var result = results[0];

                    Assert.NotEqual(Etag.InvalidEtag, result.Etag);

                    Assert.Equal("reduceKey1", result.ReduceKey);

                    Assert.True(result.Size > 0);

                    Assert.Null(result.Source);

                    Assert.Equal(UtcNow, result.Timestamp);

                    Assert.Equal("data1", result.Data["data"]);

                });



                storage.Batch(x => x.MapReduce.PutMappedResult(303, "doc1", "reduceKey1", new RavenJObject { { "data", "data2" } }));



                storage.Batch(x =>

                {

                    var results = x.MapReduce.GetMappedResults(303, new HashSet<string> { "reduceKey1" }, true, 100, new HashSet<string>(), CancellationToken.None);



                    Assert.Equal(2, results.Count);



                    var result1 = results[0];

                    Assert.NotEqual(Etag.InvalidEtag, result1.Etag);

                    Assert.Equal("reduceKey1", result1.ReduceKey);

                    Assert.True(result1.Size > 0);

                    Assert.Null(result1.Source);

                    Assert.Equal(UtcNow, result1.Timestamp);

                    Assert.Equal("data1", result1.Data["data"]);



                    var result2 = results[1];

                    Assert.NotEqual(Etag.InvalidEtag, result2.Etag);

                    Assert.Equal("reduceKey1", result2.ReduceKey);

                    Assert.True(result2.Size > 0);

                    Assert.Null(result2.Source);

                    Assert.Equal(UtcNow, result2.Timestamp);

                    Assert.Equal("data2", result2.Data["data"]);

                });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void DeleteMappedResultsForDocumentId(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(x =>

                {

                    var removed = new Dictionary<ReduceKeyAndBucket, int>();

                    x.MapReduce.DeleteMappedResultsForDocumentId("doc1", 303, removed);



                    Assert.Equal(0, removed.Count);

                });



                storage.Batch(x => x.MapReduce.PutMappedResult(303, "doc1", "reduceKey1", new RavenJObject { { "data", "data1" } }));

                storage.Batch(

                    x =>

                    {

                        var results = x.MapReduce.GetMappedResults(303, new HashSet<string>() { "reduceKey1" }, true, 100, new HashSet<string>(), CancellationToken.None);



                        Assert.Equal(1, results.Count);

                    });



                storage.Batch(x =>

                {

                    var removed = new Dictionary<ReduceKeyAndBucket, int>();

                    x.MapReduce.DeleteMappedResultsForDocumentId("doc1", 303, removed);



                    Assert.Equal(1, removed.Count);

                });



                storage.Batch(

                    x =>

                    {

                        var results = x.MapReduce.GetMappedResults(303, new HashSet<string>() { "reduceKey1" }, true, 100, new HashSet<string>(), CancellationToken.None);



                        Assert.Equal(0, results.Count);

                    });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void DeleteMappedResultsForDocumentIdMultipleMappedResults(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(x => x.MapReduce.PutMappedResult(303, "doc1", "reduceKey1", new RavenJObject { { "data", "data1" } }));

                storage.Batch(x => x.MapReduce.PutMappedResult(303, "doc1", "reduceKey1", new RavenJObject { { "data", "data2" } }));

                storage.Batch(x => x.MapReduce.PutMappedResult(303, "doc2", "reduceKey1", new RavenJObject { { "data", "data3" } }));

                storage.Batch(

                    x =>

                    {

                        var results = x.MapReduce.GetMappedResults(303, new HashSet<string>() { "reduceKey1", "reduceKey2" }, true, 100, new HashSet<string>(), CancellationToken.None);



                        Assert.Equal(3, results.Count);

                    });



                storage.Batch(x =>

                {

                    var removed = new Dictionary<ReduceKeyAndBucket, int>();

                    x.MapReduce.DeleteMappedResultsForDocumentId("doc1", 303, removed);



                    Assert.Equal(1, removed.Count);

                    var item = removed.First();



                    Assert.Equal("reduceKey1", item.Key.ReduceKey);

                    Assert.Equal(2, item.Value);

                });



                storage.Batch(

                    x =>

                    {

                        var results = x.MapReduce.GetMappedResults(303, new HashSet<string>() { "reduceKey1", "reduceKey2" }, true, 100, new HashSet<string>(), CancellationToken.None);



                        Assert.Equal(1, results.Count);

                    });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void UpdateRemovedMapReduceStats(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 7));

                storage.Batch(accessor => accessor.MapReduce.IncrementReduceKeyCounter(404, "reduceKey1", 3));



                storage.Batch(accessor =>

                {

                    var removed = new Dictionary<ReduceKeyAndBucket, int>();

                    accessor.MapReduce.UpdateRemovedMapReduceStats(303, removed, CancellationToken.None);

                });



                storage.Batch(accessor =>

                {

                    var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();

                    Assert.Equal(1, keyStats.Count);



                    var k1 = keyStats[0];

                    Assert.Equal("reduceKey1", k1.Key);

                    Assert.Equal(7, k1.Count);

                });



                storage.Batch(accessor =>

                {

                    var removed = new Dictionary<ReduceKeyAndBucket, int>

                                  {

                                      { new ReduceKeyAndBucket(123, "reduceKey1"), 3 }

                                  };



                    accessor.MapReduce.UpdateRemovedMapReduceStats(303, removed, CancellationToken.None);

                });



                storage.Batch(accessor =>

                {

                    var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();

                    Assert.Equal(1, keyStats.Count);



                    var k1 = keyStats[0];

                    Assert.Equal("reduceKey1", k1.Key);

                    Assert.Equal(4, k1.Count);

                });



                storage.Batch(accessor =>

                {

                    var removed = new Dictionary<ReduceKeyAndBucket, int>

                                  {

                                      { new ReduceKeyAndBucket(123, "reduceKey1"), 4 }

                                  };



                    accessor.MapReduce.UpdateRemovedMapReduceStats(303, removed, CancellationToken.None);

                    accessor.MapReduce.UpdateRemovedMapReduceStats(404, removed, CancellationToken.None);

                });



                storage.Batch(accessor =>

                {

                    var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();

                    Assert.Equal(0, keyStats.Count);



                    reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(404, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    keyStats = accessor.MapReduce.GetKeysStats(404, 0, 10).ToList();

                    Assert.Equal(1, keyStats.Count);



                    var k1 = keyStats[0];

                    Assert.Equal("reduceKey1", k1.Key);

                    Assert.Equal(-1, k1.Count);

                });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void DeleteMappedResultsForView(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor => accessor.MapReduce.DeleteMappedResultsForView(303, CancellationToken.None));



                storage.Batch(accessor =>

                {

                    var results = accessor.MapReduce.GetMappedResults(303, new HashSet<string>() { "reduceKey1", "reduceKey2" }, true, 100, new HashSet<string>(), CancellationToken.None);



                    Assert.Equal(0, results.Count);



                    results = accessor.MapReduce.GetMappedResults(404, new HashSet<string>() { "reduceKey1", "reduceKey2" }, true, 100, new HashSet<string>(), CancellationToken.None);



                    Assert.Equal(0, results.Count);

                });



                storage.Batch(accessor =>

                {

                    accessor.MapReduce.PutMappedResult(303, "doc1", "reduceKey1", new RavenJObject { { "data", "data1" } });

                    accessor.MapReduce.PutMappedResult(303, "doc2", "reduceKey1", new RavenJObject { { "data", "data2" } });

                    accessor.MapReduce.PutMappedResult(303, "doc1", "reduceKey2", new RavenJObject { { "data", "data3" } });

                    accessor.MapReduce.PutMappedResult(404, "doc1", "reduceKey1", new RavenJObject { { "data", "data4" } });

                    accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey1", 2);

                    accessor.MapReduce.IncrementReduceKeyCounter(303, "reduceKey2", 1);

                    accessor.MapReduce.IncrementReduceKeyCounter(404, "reduceKey1", 1);

                });



                storage.Batch(accessor =>

                {

                    var results = accessor.MapReduce.GetMappedResults(303, new HashSet<string>() { "reduceKey1", "reduceKey2" }, true, 100, new HashSet<string>(), CancellationToken.None);



                    Assert.Equal(3, results.Count);



                    var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();

                    Assert.Equal(2, keyStats.Count);



                    var k1 = keyStats[0];

                    Assert.Equal("reduceKey1", k1.Key);

                    Assert.Equal(2, k1.Count);



                    var k2 = keyStats[1];

                    Assert.Equal("reduceKey2", k2.Key);

                    Assert.Equal(1, k2.Count);



                    results = accessor.MapReduce

                       .GetMappedResults(404, new HashSet<string>() { "reduceKey1", "reduceKey2" }, true, 100, new HashSet<string>(), CancellationToken.None)

                       .ToList();



                    Assert.Equal(1, results.Count);



                    reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(404, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    keyStats = accessor.MapReduce.GetKeysStats(404, 0, 10).ToList();

                    Assert.Equal(1, keyStats.Count);



                    k1 = keyStats[0];

                    Assert.Equal("reduceKey1", k1.Key);

                    Assert.Equal(1, k1.Count);

                });



                storage.Batch(accessor => accessor.MapReduce.DeleteMappedResultsForView(303, CancellationToken.None));



                storage.Batch(accessor =>

                {

                    var results = accessor.MapReduce.GetMappedResults(303, new HashSet<string>() { "reduceKey1", "reduceKey2" }, true, 100, new HashSet<string>(), CancellationToken.None);



                    Assert.Equal(0, results.Count);



                    var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();

                    Assert.Equal(0, keyStats.Count);



                    results = accessor.MapReduce.GetMappedResults(404, new HashSet<string>() { "reduceKey1", "reduceKey2" }, true, 100, new HashSet<string>(), CancellationToken.None);



                    Assert.Equal(1, results.Count);



                    reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(404, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    keyStats = accessor.MapReduce.GetKeysStats(404, 0, 10).ToList();

                    Assert.Equal(1, keyStats.Count);



                    var k1 = keyStats[0];

                    Assert.Equal("reduceKey1", k1.Key);

                    Assert.Equal(1, k1.Count);

                });



                storage.Batch(accessor => accessor.MapReduce.DeleteMappedResultsForView(404, CancellationToken.None));



                storage.Batch(accessor =>

                {

                    var results = accessor.MapReduce.GetMappedResults(303, new HashSet<string>() { "reduceKey1", "reduceKey2" }, true, 100, new HashSet<string>(), CancellationToken.None);



                    Assert.Equal(0, results.Count);



                    var reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(303, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    var keyStats = accessor.MapReduce.GetKeysStats(303, 0, 10).ToList();

                    Assert.Equal(0, keyStats.Count);



                    results = accessor.MapReduce.GetMappedResults(404, new HashSet<string>() { "reduceKey1", "reduceKey2" }, true, 100, new HashSet<string>(), CancellationToken.None);



                    Assert.Equal(0, results.Count);



                    reduceKeysAndTypes = accessor.MapReduce.GetReduceKeysAndTypes(404, 0, 10).ToList();

                    Assert.Equal(0, reduceKeysAndTypes.Count);



                    keyStats = accessor.MapReduce.GetKeysStats(404, 0, 10).ToList();

                    Assert.Equal(0, keyStats.Count);

                });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void GetKeysForIndexForDebug1(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor =>

                {

                    accessor.MapReduce.PutMappedResult(303, "doc1", "reduceKey1", new RavenJObject { { "data", "data1" } });

                    accessor.MapReduce.PutMappedResult(303, "doc2", "reduceKey2", new RavenJObject { { "data", "data2" } });

                    accessor.MapReduce.PutMappedResult(303, "doc3", "reduceKey3", new RavenJObject { { "data", "data3" } });

                    accessor.MapReduce.PutMappedResult(404, "doc1", "reduceKey4", new RavenJObject { { "data", "data4" } });

                });



                storage.Batch(accessor =>

                {

                    var keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, null, 0, 10)

                        .ToList();



                    Assert.Equal(3, keys.Count);

                    Assert.True(keys.Contains("reduceKey1"));

                    Assert.True(keys.Contains("reduceKey2"));

                    Assert.True(keys.Contains("reduceKey3"));



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(404, null, null, 0, 10)

                        .ToList();



                    Assert.Equal(1, keys.Count);

                    Assert.Equal("reduceKey4", keys[0]);



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(505, null, null, 0, 10)

                        .ToList();



                    Assert.Equal(0, keys.Count);

                });



                storage.Batch(accessor =>

                {

                    var keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, null, 0, 10)

                        .ToList();



                    var k1 = keys[0];

                    var k2 = keys[1];

                    var k3 = keys[2];



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, null, 0, 1)

                        .ToList();



                    Assert.Equal(1, keys.Count);

                    Assert.Equal(k1, keys[0]);



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, null, 1, 1)

                        .ToList();



                    Assert.Equal(1, keys.Count);

                    Assert.Equal(k2, keys[0]);



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, null, 2, 1)

                        .ToList();



                    Assert.Equal(1, keys.Count);

                    Assert.Equal(k3, keys[0]);



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, null, 3, 1)

                        .ToList();



                    Assert.Equal(0, keys.Count);



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, null, 0, 2)

                        .ToList();



                    Assert.Equal(2, keys.Count);

                    Assert.Equal(k1, keys[0]);

                    Assert.Equal(k2, keys[1]);



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, null, 1, 2)

                        .ToList();



                    Assert.Equal(2, keys.Count);

                    Assert.Equal(k2, keys[0]);

                    Assert.Equal(k3, keys[1]);



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, null, 2, 2)

                        .ToList();



                    Assert.Equal(1, keys.Count);

                    Assert.Equal(k3, keys[0]);

                });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void GetKeysForIndexForDebug2(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor =>

                {

                    accessor.MapReduce.PutMappedResult(303, "doc1", "reduceKey/1", new RavenJObject { { "data", "data1" } });

                    accessor.MapReduce.PutMappedResult(303, "doc2", "reduceKey/2", new RavenJObject { { "data", "data2" } });

                    accessor.MapReduce.PutMappedResult(303, "doc3", "reduceKey/3", new RavenJObject { { "data", "data3" } });

                    accessor.MapReduce.PutMappedResult(404, "doc1", "reduceKey/4", new RavenJObject { { "data", "data4" } });

                    accessor.MapReduce.PutMappedResult(303, "doc1", "reduceKey/10", new RavenJObject { { "data", "data5" } });

                });



                storage.Batch(accessor =>

                {

                    var keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, "reduceKey", null, 0, 10)

                        .ToList();



                    Assert.Equal(4, keys.Count);

                    Assert.True(keys.Contains("reduceKey/1"));

                    Assert.True(keys.Contains("reduceKey/2"));

                    Assert.True(keys.Contains("reduceKey/3"));

                    Assert.True(keys.Contains("reduceKey/10"));



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, "reduceKey/1", null, 0, 10)

                        .ToList();



                    Assert.Equal(2, keys.Count);

                    Assert.True(keys.Contains("reduceKey/1"));

                    Assert.True(keys.Contains("reduceKey/10"));

                });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void GetKeysForIndexForDebug3(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor =>

                {

                    accessor.MapReduce.PutMappedResult(303, "doc1", "reduceKey/1", new RavenJObject { { "data", "data1" } });

                    accessor.MapReduce.PutMappedResult(303, "doc2", "reduceKey/2", new RavenJObject { { "data", "data2" } });

                    accessor.MapReduce.PutMappedResult(303, "doc3", "reduceKey/3", new RavenJObject { { "data", "data3" } });

                    accessor.MapReduce.PutMappedResult(404, "doc1", "reduceKey/4", new RavenJObject { { "data", "data4" } });

                    accessor.MapReduce.PutMappedResult(303, "doC1", "reduceKey/10", new RavenJObject { { "data", "data5" } });

                });



                storage.Batch(accessor =>

                {

                    var keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, "doc1", 0, 10)

                        .ToList();



                    Assert.Equal(2, keys.Count);

                    Assert.True(keys.Contains("reduceKey/1"));

                    Assert.True(keys.Contains("reduceKey/10"));



                    keys = accessor.MapReduce

                        .GetKeysForIndexForDebug(303, null, "doc2", 0, 10)

                        .ToList();



                    Assert.Equal(1, keys.Count);

                    Assert.True(keys.Contains("reduceKey/2"));

                });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void GetMappedResultsForDebug(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor =>

                {

                    accessor.MapReduce.PutMappedResult(303, "doc1", "reduceKey1", new RavenJObject { { "data", "data1" } });

                    accessor.MapReduce.PutMappedResult(303, "doc2", "reduceKey2", new RavenJObject { { "data", "data2" } });

                    accessor.MapReduce.PutMappedResult(303, "doc3", "reduceKey1", new RavenJObject { { "data", "data3" } });

                    accessor.MapReduce.PutMappedResult(303, "doc4", "reduceKey1", new RavenJObject { { "data", "data4" } });

                    accessor.MapReduce.PutMappedResult(404, "doc1", "reduceKey4", new RavenJObject { { "data", "data5" } });

                });



                storage.Batch(accessor =>

                {

                    var results = accessor.MapReduce

                        .GetMappedResultsForDebug(303, "reduceKey1", 0, 10)

                        .ToList();



                    Assert.Equal(3, results.Count);



                    results = accessor.MapReduce

                        .GetMappedResultsForDebug(303, "reduceKey2", 0, 10)

                        .ToList();



                    Assert.Equal(1, results.Count);



                    results = accessor.MapReduce

                        .GetMappedResultsForDebug(404, "reduceKey4", 0, 10)

                        .ToList();



                    Assert.Equal(1, results.Count);



                    results = accessor.MapReduce

                        .GetMappedResultsForDebug(505, "reduceKey1", 0, 10)

                        .ToList();



                    Assert.Equal(0, results.Count);

                });



                storage.Batch(accessor =>

                {

                    var results = accessor.MapReduce

                        .GetMappedResultsForDebug(303, "reduceKey1", 0, 10)

                        .ToList();



                    var r1 = results[0];

                    var r2 = results[1];

                    var r3 = results[2];



                    results = accessor.MapReduce

                        .GetMappedResultsForDebug(303, "reduceKey1", 0, 1)

                        .ToList();



                    Assert.Equal(1, results.Count);

                    Assert.Equal(r1.Data["data"], results[0].Data["data"]);



                    results = accessor.MapReduce

                        .GetMappedResultsForDebug(303, "reduceKey1", 1, 1)

                        .ToList();



                    Assert.Equal(1, results.Count);

                    Assert.Equal(r2.Data["data"], results[0].Data["data"]);



                    results = accessor.MapReduce

                        .GetMappedResultsForDebug(303, "reduceKey1", 2, 1)

                        .ToList();



                    Assert.Equal(1, results.Count);

                    Assert.Equal(r3.Data["data"], results[0].Data["data"]);



                    results = accessor.MapReduce

                        .GetMappedResultsForDebug(303, "reduceKey1", 4, 1)

                        .ToList();



                    Assert.Equal(0, results.Count);



                    results = accessor.MapReduce

                        .GetMappedResultsForDebug(303, "reduceKey1", 0, 2)

                        .ToList();



                    Assert.Equal(2, results.Count);

                    Assert.Equal(r1.Data["data"], results[0].Data["data"]);

                    Assert.Equal(r2.Data["data"], results[1].Data["data"]);



                    results = accessor.MapReduce

                        .GetMappedResultsForDebug(303, "reduceKey1", 1, 2)

                        .ToList();



                    Assert.Equal(2, results.Count);

                    Assert.Equal(r2.Data["data"], results[0].Data["data"]);

                    Assert.Equal(r3.Data["data"], results[1].Data["data"]);



                    results = accessor.MapReduce

                        .GetMappedResultsForDebug(303, "reduceKey1", 2, 2)

                        .ToList();



                    Assert.Equal(1, results.Count);

                    Assert.Equal(r3.Data["data"], results[0].Data["data"]);

                });

            }

        }



        [Theory]

        [PropertyData("Storages")]

        public void GetReducedResultsForDebug(string requestedStorage)

        {

            using (var storage = NewTransactionalStorage(requestedStorage))

            {

                storage.Batch(accessor =>

                {

                    accessor.MapReduce.PutReducedResult(303, "doc1", 1, 1, 1, new RavenJObject { { "data", "data1" } });

                    accessor.MapReduce.PutReducedResult(303, "doc2", 1, 1, 1, new RavenJObject { { "data", "data2" } });

                    accessor.MapReduce.PutReducedResult(303, "doc1", 2, 2, 1, new RavenJObject { { "data", "data3" } });

                    accessor.MapReduce.PutReducedResult(303, "doc1", 1, 1, 1, new RavenJObject { { "data", "data4" } });

                    accessor.MapReduce.PutReducedResult(303, "doc1", 1, 2, 1, new RavenJObject { { "data", "data5" } });

                    accessor.MapReduce.PutReducedResult(303, "doc1", 2, 1, 1, new RavenJObject { { "data", "data6" } });

                    accessor.MapReduce.PutReducedResult(404, "doc1", 1, 1, 1, new RavenJObject { { "data", "data7" } });

                });



                storage.Batch(accessor =>

                {

                    var results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc1", 1, 0, 10)

                        .ToList();



                    Assert.Equal(3, results.Count);



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc2", 1, 0, 10)

                        .ToList();



                    Assert.Equal(1, results.Count);



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc1", 2, 0, 10)

                        .ToList();



                    Assert.Equal(2, results.Count);



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(404, "doc1", 1, 0, 10)

                        .ToList();



                    Assert.Equal(1, results.Count);



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc5", 1, 0, 10)

                        .ToList();



                    Assert.Equal(0, results.Count);

                });



                storage.Batch(accessor =>

                {

                    var results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc1", 1, 0, 10)

                        .ToList();



                    var r1 = results[0];

                    var r2 = results[1];

                    var r3 = results[2];



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc1", 1, 0, 1)

                        .ToList();



                    Assert.Equal(1, results.Count);

                    Assert.Equal(r1.Data["data"], results[0].Data["data"]);



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc1", 1, 1, 1)

                        .ToList();



                    Assert.Equal(1, results.Count);

                    Assert.Equal(r2.Data["data"], results[0].Data["data"]);



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc1", 1, 2, 1)

                        .ToList();



                    Assert.Equal(1, results.Count);

                    Assert.Equal(r3.Data["data"], results[0].Data["data"]);



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc1", 1, 4, 1)

                        .ToList();



                    Assert.Equal(0, results.Count);



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc1", 1, 0, 2)

                        .ToList();



                    Assert.Equal(2, results.Count);

                    Assert.Equal(r1.Data["data"], results[0].Data["data"]);

                    Assert.Equal(r2.Data["data"], results[1].Data["data"]);



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc1", 1, 1, 2)

                        .ToList();



                    Assert.Equal(2, results.Count);

                    Assert.Equal(r2.Data["data"], results[0].Data["data"]);

                    Assert.Equal(r3.Data["data"], results[1].Data["data"]);



                    results = accessor.MapReduce

                        .GetReducedResultsForDebug(303, "doc1", 1, 2, 2)

                        .ToList();



                    Assert.Equal(1, results.Count);

                    Assert.Equal(r3.Data["data"], results[0].Data["data"]);

                });

            }

        }



        [Theory]

        [PropertyData("Storages"