﻿/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// ReSharper disable UnusedMember.Local
// ReSharper disable UnusedAutoPropertyAccessor.Local
// ReSharper disable ClassWithVirtualMembersNeverInherited.Local
// ReSharper disable UnusedAutoPropertyAccessor.Global
// ReSharper disable VirtualMemberNeverOverridden.Global

namespace Apache.Ignite.EntityFramework.Tests
{
    using System;
    using System.Collections.Generic;
    using System.Data;
    using System.Data.Entity;
    using System.Data.Entity.Core.EntityClient;
    using System.Data.Entity.Infrastructure;
    using System.IO;
    using System.Linq;
    using System.Threading;
    using System.Transactions;
    using Apache.Ignite.Core;
    using Apache.Ignite.Core.Cache;
    using Apache.Ignite.Core.Tests;
    using Apache.Ignite.EntityFramework;
    using Apache.Ignite.EntityFramework.Impl;
    using NUnit.Framework;

    /// <summary>
    /// Integration test with temporary SQL CE database.
    /// </summary>
    public class EntityFrameworkCacheTest
    {
        /** */
        private static readonly string TempFile = Path.GetTempFileName();

        /** */
        private static readonly string ConnectionString = "Datasource = " + TempFile;

        /** */
        private static readonly DelegateCachingPolicy Policy = new DelegateCachingPolicy();

        /** */
        private ICache<object, object> _cache;

        /** */
        private ICache<object, object> _metaCache;

        /// <summary>
        /// Fixture set up.
        /// </summary>
        [TestFixtureSetUp]
        public void FixtureSetUp()
        {
            // Start 2 nodes.
            var cfg = TestUtils.GetTestConfiguration();
            var ignite = Ignition.Start(cfg);

            Ignition.Start(new IgniteConfiguration(cfg) {IgniteInstanceName = "grid2"});

            // Create SQL CE database in a temp file.
            using (var ctx = GetDbContext())
            {
                File.Delete(TempFile);
                ctx.Database.Create();
            }

            // Get the caches.
            _cache = ignite.GetCache<object, object>("entityFrameworkQueryCache_data")
                .WithKeepBinary<object, object>();

            _metaCache = ignite.GetCache<object, object>("entityFrameworkQueryCache_metadata")
                .WithKeepBinary<object, object>();
        }

        /// <summary>
        /// Fixture tear down.
        /// </summary>
        [TestFixtureTearDown]
        public void FixtureTearDown()
        {
            using (var ctx = GetDbContext())
            {
                ctx.Database.Delete();
            }

            Ignition.StopAll(true);
            File.Delete(TempFile);
        }

        /// <summary>
        /// Sets up the test.
        /// </summary>
        [SetUp]
        public void TestSetUp()
        {
            // Reset the policy.
            Policy.CanBeCachedFunc = null;
            Policy.CanBeCachedRowsFunc = null;
            Policy.GetExpirationTimeoutFunc = null;
            Policy.GetCachingStrategyFunc = null;

            // Clean up the db.
            using (var ctx = GetDbContext())
            {
                ctx.Blogs.RemoveRange(ctx.Blogs);
                ctx.Posts.RemoveRange(ctx.Posts);
                ctx.Tests.RemoveRange(ctx.Tests);

                ctx.SaveChanges();
            }

            using (var ctx = GetDbContext())
            {
                Assert.IsEmpty(ctx.Blogs);
                Assert.IsEmpty(ctx.Posts);
            }

            // Clear the caches.
            _cache.Clear();
            _metaCache.Clear();
        }

        /// <summary>
        /// Tests that caching actually happens.
        /// </summary>
        [Test]
        public void TestResultFromCache()
        {
            using (var ctx = GetDbContext())
            {
                // Add data.
                ctx.Posts.Add(new Post {Title = "Foo", Blog = new Blog(), PostId = 1});
                ctx.Posts.Add(new Post {Title = "Bar", Blog = new Blog(), PostId = 2});
                ctx.SaveChanges();

                Assert.AreEqual(new[] {"Foo"}, ctx.Posts.Where(x => x.Title == "Foo").Select(x => x.Title).ToArray());
                Assert.AreEqual(new[] {"Bar"}, ctx.Posts.Where(x => x.Title == "Bar").Select(x => x.Title).ToArray());

                // Alter cached data: swap cached values.
                
                var cachedData = _cache.ToArray();

                Assert.AreEqual(2, cachedData.Length);

                _cache[cachedData[0].Key] = cachedData[1].Value;
                _cache[cachedData[1].Key] = cachedData[0].Value;

                // Verify.
                Assert.AreEqual(new[] {"Bar"}, ctx.Posts.Where(x => x.Title == "Foo").Select(x => x.Title).ToArray());
                Assert.AreEqual(new[] {"Foo"}, ctx.Posts.Where(x => x.Title == "Bar").Select(x => x.Title).ToArray());
            }
        }

        /// <summary>
        /// Tests the read-write strategy (default).
        /// </summary>
        [Test]
        public void TestReadWriteStrategy()
        {
            using (var ctx = GetDbContext())
            {
                var blog = new Blog
                {
                    Name = "Foo",
                    Posts = new List<Post>
                    {
                        new Post {Title = "My First Post", Content = "Hello World!"}
                    }
                };
                ctx.Blogs.Add(blog);

                Assert.AreEqual(2, ctx.SaveChanges());

                // Check that query works.
                Assert.AreEqual(1, ctx.Posts.Where(x => x.Title.StartsWith("My")).ToArray().Length);

                // Add new post to check invalidation.
                ctx.Posts.Add(new Post {BlogId = blog.BlogId, Title = "My Second Post", Content = "Foo bar."});
                Assert.AreEqual(1, ctx.SaveChanges());

                Assert.AreEqual(0, _cache.GetSize()); // No cached entries.

                Assert.AreEqual(2, ctx.Posts.Where(x => x.Title.StartsWith("My")).ToArray().Length);

                Assert.AreEqual(1, _cache.GetSize()); // Cached query added.

                // Delete post.
                ctx.Posts.Remove(ctx.Posts.First());
                Assert.AreEqual(1, ctx.SaveChanges());

                Assert.AreEqual(0, _cache.GetSize()); // No cached entries.
                Assert.AreEqual(1, ctx.Posts.Where(x => x.Title.StartsWith("My")).ToArray().Length);

                Assert.AreEqual(1, _cache.GetSize()); // Cached query added.

                // Modify post.
                Assert.AreEqual(0, ctx.Posts.Count(x => x.Title.EndsWith("updated")));

                ctx.Posts.Single().Title += " - updated";
                Assert.AreEqual(1, ctx.SaveChanges());

                Assert.AreEqual(0, _cache.GetSize()); // No cached entries.
                Assert.AreEqual(1, ctx.Posts.Count(x => x.Title.EndsWith("updated")));

                Assert.AreEqual(1, _cache.GetSize()); // Cached query added.
            }
        }

        /// <summary>
        /// Tests the read only strategy.
        /// </summary>
        [Test]
        public void TestReadOnlyStrategy()
        {
            // Set up a policy to cache Blogs as read-only and Posts as read-write.
            Policy.GetCachingStrategyFunc = q =>
                q.AffectedEntitySets.Count == 1 && q.AffectedEntitySets.Single().Name == "Blog"
                    ? DbCachingMode.ReadOnly
                    : DbCachingMode.ReadWrite;

            using (var ctx = GetDbContext())
            {
                ctx.Blogs.Add(new Blog
                {
                    Name = "Foo",
                    Posts = new List<Post>
                    {
                        new Post {Title = "Post"}
                    }
                });

                ctx.SaveChanges();

                // Update entities.
                Assert.AreEqual("Foo", ctx.Blogs.Single().Name);
                Assert.AreEqual("Post", ctx.Posts.Single().Title);

                ctx.Blogs.Single().Name += " - updated";
                ctx.Posts.Single().Title += " - updated";

                ctx.SaveChanges();
            }

            // Verify that cached result is not changed for blogs, but changed for posts.
            using (var ctx = GetDbContext())
            {
                // Raw SQL queries do not hit cache - verify that actual data is updated.
                Assert.AreEqual("Foo - updated", ctx.Database.SqlQuery<string>("select name from blogs").Single());
                Assert.AreEqual("Post - updated", ctx.Database.SqlQuery<string>("select title from posts").Single());

                // Check EF queries that hit cache.
                Assert.AreEqual("Foo", ctx.Blogs.Single().Name);
                Assert.AreEqual("Post - updated", ctx.Posts.Single().Title);

            }

            // Clear the cache and verify that actual value in DB is changed.
            _cache.Clear();

            using (var ctx = GetDbContext())
            {
                Assert.AreEqual("Foo - updated", ctx.Blogs.Single().Name);
                Assert.AreEqual("Post - updated", ctx.Posts.Single().Title);
            }
        }

        /// <summary>
        /// Tests the scalar queries.
        /// </summary>
        [Test]
        public void TestScalars()
        {
            using (var ctx = GetDbContext())
            {
                var blog = new Blog
                {
                    Name = "Foo",
                    Posts = new List<Post>
                    {
                        new Post {Title = "1"},
                        new Post {Title = "2"},
                        new Post {Title = "3"},
                        new Post {Title = "4"}
                    }
                };
                ctx.Blogs.Add(blog);

                Assert.AreEqual(5, ctx.SaveChanges());

                // Test sum and count.
                const string esql = "SELECT COUNT(1) FROM [BloggingContext].Posts";

                Assert.AreEqual(4, ctx.Posts.Count());
                Assert.AreEqual(4, ctx.Posts.Count(x => x.Content == null));
                Assert.AreEqual(4, GetEntityCommand(ctx, esql).ExecuteScalar());
                Assert.AreEqual(blog.BlogId*4, ctx.Posts.Sum(x => x.BlogId));

                ctx.Posts.Remove(ctx.Posts.First());
                ctx.SaveChanges();

                Assert.AreEqual(3, ctx.Posts.Count());
                Assert.AreEqual(3, ctx.Posts.Count(x => x.Content == null));
                Assert.AreEqual(3, GetEntityCommand(ctx, esql).ExecuteScalar());
                Assert.AreEqual(blog.BlogId*3, ctx.Posts.Sum(x => x.BlogId));
            }
        }

        /// <summary>
        /// Queries with entity sets used multiple times are handled correctly.
        /// </summary>
        [Test]
        public void TestDuplicateEntitySets()
        {
            using (var ctx = GetDbContext())
            {
                var blog = new Blog
                {
                    Name = "Foo",
                    Posts = new List<Post>
                    {
                        new Post {Title = "Foo"},
                        new Post {Title = "Foo"},
                        new Post {Title = "Foo"},
                        new Post {Title = "Bar"}
                    }
                };
                ctx.Blogs.Add(blog);

                Assert.AreEqual(5, ctx.SaveChanges());

                var res = ctx.Blogs.Select(b => new
                {
                    X = b.Posts.FirstOrDefault(p => p.Title == b.Name),
                    Y = b.Posts.Count(p => p.Title == b.Name)
                }).ToArray();

                Assert.AreEqual(1, res.Length);
                Assert.AreEqual("Foo", res[0].X.Title);
                Assert.AreEqual(3, res[0].Y);

                // Modify and check updated result.
                ctx.Posts.Remove(ctx.Posts.First(x => x.Title == "Foo"));
                Assert.AreEqual(1, ctx.SaveChanges());

                res = ctx.Blogs.Select(b => new
                {
                    X = b.Posts.FirstOrDefault(p => p.Title == b.Name),
                    Y = b.Posts.Count(p => p.Title == b.Name)
                }).ToArray();

                Assert.AreEqual(1, res.Length);
                Assert.AreEqual("Foo", res[0].X.Title);
                Assert.AreEqual(2, res[0].Y);
            }
        }

        /// <summary>
        /// Tests transactions created with BeginTransaction.
        /// </summary>
        [Test]
        public void TestTx()
        {
            // Check TX without commit.
            using (var ctx = GetDbContext())
            {
                using (ctx.Database.BeginTransaction())
                {
                    ctx.Posts.Add(new Post {Title = "Foo", Blog = new Blog()});
                    ctx.SaveChanges();

                    Assert.AreEqual(1, ctx.Posts.ToArray().Length);
                }
            }

            using (var ctx = GetDbContext())
            {
                Assert.AreEqual(0, ctx.Posts.ToArray().Length);
            }

            // Check TX with commit.
            using (var ctx = GetDbContext())
            {
                using (var tx = ctx.Database.BeginTransaction())
                {
                    ctx.Posts.Add(new Post {Title = "Foo", Blog = new Blog()});
                    ctx.SaveChanges();

                    Assert.AreEqual(1, ctx.Posts.ToArray().Length);

                    tx.Commit();

                    Assert.AreEqual(1, ctx.Posts.ToArray().Length);
                }
            }

            using (var ctx = GetDbContext())
            {
                Assert.AreEqual(1, ctx.Posts.ToArray().Length);
            }
        }

        /// <summary>
        /// Tests transactions created with TransactionScope.
        /// </summary>
        [Test]
        public void TestTxScope()
        {
            // Check TX without commit.
            using (new TransactionScope())
            {
                using (var ctx = GetDbContext())
                {
                    ctx.Posts.Add(new Post {Title = "Foo", Blog = new Blog()});
                    ctx.SaveChanges();
                }
            }

            using (var ctx = GetDbContext())
            {
                Assert.AreEqual(0, ctx.Posts.ToArray().Length);
            }

            // Check TX with commit.
            using (var tx = new TransactionScope())
            {
                using (var ctx = GetDbContext())
                {
                    ctx.Posts.Add(new Post {Title = "Foo", Blog = new Blog()});
                    ctx.SaveChanges();
                }

                tx.Complete();
            }

            using (var ctx = GetDbContext())
            {
                Assert.AreEqual(1, ctx.Posts.ToArray().Length);
            }
        }

        /// <summary>
        /// Tests the expiration.
        /// </summary>
        [Test]
        public void TestExpiration()
        {
            Policy.GetExpirationTimeoutFunc = qry => TimeSpan.FromSeconds(0.3);

            using (var ctx = GetDbContext())
            {
                ctx.Posts.Add(new Post {Title = "Foo", Blog = new Blog()});
                ctx.SaveChanges();

                Assert.AreEqual(1, ctx.Posts.ToArray().Length);
                Assert.AreEqual(1, _cache.GetSize());

                var key = _cache.Single().Key;
                Assert.IsTrue(_cache.ContainsKey(key));

                Thread.Sleep(300);

                Assert.IsFalse(_cache.ContainsKey(key));
                Assert.AreEqual(0, _cache.GetSize());
                Assert.AreEqual(2, _metaCache.GetSize());
            }
        }

        /// <summary>
        /// Tests the caching policy.
        /// </summary>
        [Test]
        public void TestCachingPolicy()
        {
            var funcs = new List<string>();

            var checkQry = (Action<DbQueryInfo>) (qry =>
                {
                    var set = qry.AffectedEntitySets.Single();

                    Assert.AreEqual("Post", set.Name);

                    Assert.AreEqual(1, qry.Parameters.Count);
                    Assert.AreEqual(-5, qry.Parameters[0].Value);
                    Assert.AreEqual(DbType.Int32, qry.Parameters[0].DbType);

                    Assert.IsTrue(qry.CommandText.EndsWith("WHERE [Extent1].[BlogId] > @p__linq__0"));
                }
            );

            Policy.CanBeCachedFunc = qry =>
            {
                funcs.Add("CanBeCached");
                checkQry(qry);
                return true;
            };

            Policy.CanBeCachedRowsFunc = (qry, rows) =>
            {
                funcs.Add("CanBeCachedRows");
                Assert.AreEqual(3, rows);
                checkQry(qry);
                return true;
            };

            Policy.GetCachingStrategyFunc = qry =>
            {
                funcs.Add("GetCachingStrategy");
                checkQry(qry);
                return DbCachingMode.ReadWrite;
            };

            Policy.GetExpirationTimeoutFunc = qry =>
            {
                funcs.Add("GetExpirationTimeout");
                checkQry(qry);
                return TimeSpan.MaxValue;
            };

            using (var ctx = GetDbContext())
            {
                var blog = new Blog();

                ctx.Posts.Add(new Post {Title = "Foo", Blog = blog});
                ctx.Posts.Add(new Post {Title = "Bar", Blog = blog});
                ctx.Posts.Add(new Post {Title = "Baz", Blog = blog});

                ctx.SaveChanges();

                int minId = -5;
                Assert.AreEqual(3, ctx.Posts.Where(x => x.BlogId > minId).ToArray().Length);

                // Check that policy methods are called in correct order with correct params.
                Assert.AreEqual(
                    new[] {"GetCachingStrategy", "CanBeCached", "CanBeCachedRows", "GetExpirationTimeout"},
                    funcs.ToArray());
            }
        }

        /// <summary>
        /// Tests the cache reader indirectly with an entity that has various field types.
        /// </summary>
        [Test]
        public void TestCacheReader()
        {
            // Tests all kinds of entity field types to cover ArrayDbDataReader.
            var test = GetTestEntity();

            using (var ctx = new BloggingContext(ConnectionString))
            {
                ctx.Tests.Add(test);
                ctx.SaveChanges();
            }

            // Use new context to ensure no first-level caching.
            using (var ctx = new BloggingContext(ConnectionString))
            {
                // Check default deserialization.
                var test0 = ctx.Tests.Single(x => x.Bool);
                Assert.AreEqual(test, test0);
            }
        }

        /// <summary>
        /// Tests the cache reader by calling it directly.
        /// These calls are (partly) delegated by EF to the <see cref="ArrayDbDataReader"/>.
        /// </summary>
        [Test]
        public void TestCacheReaderRaw()
        {
            var test = GetTestEntity();

            using (var ctx = new BloggingContext(ConnectionString))
            {
                ctx.Tests.Add(test);
                ctx.SaveChanges();

                test = ctx.Tests.Single();
            }

            using (var ctx = new BloggingContext(ConnectionString))
            {
                var cmd = GetEntityCommand(ctx, "SELECT VALUE Test FROM BloggingContext.Tests AS Test");

                using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
                {
                    // Check schema.
                    Assert.Throws<NotSupportedException>(() => reader.GetSchemaTable());
                    Assert.AreEqual(0, reader.Depth);
                    Assert.AreEqual(-1, reader.RecordsAffected);
                    Assert.IsTrue(reader.HasRows);
                    Assert.IsFalse(reader.IsClosed);
                    Assert.AreEqual(11, reader.FieldCount);
                    Assert.AreEqual(11, reader.VisibleFieldCount);

                    // Check field names.
                    Assert.AreEqual("Edm.Int32", reader.GetDataTypeName(0));
                    Assert.AreEqual("Edm.Byte", reader.GetDataTypeName(1));
                    Assert.AreEqual("Edm.Int16", reader.GetDataTypeName(2));
                    Assert.AreEqual("Edm.Int64", reader.GetDataTypeName(3));
                    Assert.AreEqual("Edm.Single", reader.GetDataTypeName(4));
                    Assert.AreEqual("Edm.Double", reader.GetDataTypeName(5));
                    Assert.AreEqual("Edm.Decimal", reader.GetDataTypeName(6));
                    Assert.AreEqual("Edm.Boolean", reader.GetDataTypeName(7));
                    Assert.AreEqual("Edm.String", reader.GetDataTypeName(8));
                    Assert.AreEqual("Edm.Guid", reader.GetDataTypeName(9));
                    Assert.AreEqual("Edm.DateTime", reader.GetDataTypeName(10));

                    // Check field types.
                    Assert.AreEqual(typeof(int), reader.GetFieldType(0));
                    Assert.AreEqual(typeof(byte), reader.GetFieldType(1));
                    Assert.AreEqual(typeof(short), reader.GetFieldType(2));
                    Assert.AreEqual(typeof(long), reader.GetFieldType(3));
                    Assert.AreEqual(typeof(float), reader.GetFieldType(4));
                    Assert.AreEqual(typeof(double), reader.GetFieldType(5));
                    Assert.AreEqual(typeof(decimal), reader.GetFieldType(6));
                    Assert.AreEqual(typeof(bool), reader.GetFieldType(7));
                    Assert.AreEqual(typeof(string), reader.GetFieldType(8));
                    Assert.AreEqual(typeof(Guid), reader.GetFieldType(9));
                    Assert.AreEqual(typeof(DateTime), reader.GetFieldType(10));

                    // Read.
                    Assert.IsTrue(reader.Read());

                    // Test values array.
                    var vals = new object[reader.FieldCount];
                    reader.GetValues(vals);

                    Assert.AreEqual(test.Byte, vals[reader.GetOrdinal("Byte")]);
                    Assert.AreEqual(test.Short, vals[reader.GetOrdinal("Short")]);
                    Assert.AreEqual(test.ArrayReaderTestId, vals[reader.GetOrdinal("ArrayReaderTestId")]);
                    Assert.AreEqual(test.Long, vals[reader.GetOrdinal("Long")]);
                    Assert.AreEqual(test.Float, vals[reader.GetOrdinal("Float")]);
                    Assert.AreEqual(test.Double, vals[reader.GetOrdinal("Double")]);
                    Assert.AreEqual(test.Decimal, vals[reader.GetOrdinal("Decimal")]);
                    Assert.AreEqual(test.Bool, vals[reader.GetOrdinal("Bool")]);
                    Assert.AreEqual(test.String, vals[reader.GetOrdinal("String")]);
                    Assert.AreEqual(test.Guid, vals[reader.GetOrdinal("Guid")]);
                    Assert.AreEqual(test.DateTime, vals[reader.GetOrdinal("DateTime")]);
                }

                using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
                {
                    // Read.
                    Assert.IsTrue(reader.Read());

                    // Test separate values.
                    Assert.AreEqual(test.ArrayReaderTestId, reader.GetInt32(0));
                    Assert.AreEqual(test.Byte, reader.GetByte(1));
                    Assert.AreEqual(test.Short, reader.GetInt16(2));
                    Assert.AreEqual(test.Long, reader.GetInt64(3));
                    Assert.AreEqual(test.Float, reader.GetFloat(4));
                    Assert.AreEqual(test.Double, reader.GetDouble(5));
                    Assert.AreEqual(test.Decimal, reader.GetDecimal(6));
                    Assert.AreEqual(test.Bool, reader.GetBoolean(7));
                    Assert.AreEqual(test.String, reader.GetString(8));
                    Assert.AreEqual(test.Guid, reader.GetGuid(9));
                    Assert.AreEqual(test.DateTime, reader.GetDateTime(10));
                }
            }
        }

        /// <summary>
        /// Tests the database context.
        /// </summary>
        [Test]
        public void TestDbContext()
        {
            using (var ctx = GetDbContext())
            {
                var objCtx = ((IObjectContextAdapter) ctx).ObjectContext;

                var script = objCtx.CreateDatabaseScript();
                Assert.IsTrue(script.StartsWith("CREATE TABLE \"Blogs\""));
            }
        }

        /// <summary>
        /// Tests that old versions of caches entries are cleaned up.
        /// </summary>
        [Test]
        public void TestOldEntriesCleanup()
        {
            // Run in a loop to generate a bunch of outdated cache entries.
            for (var i = 0; i < 100; i++)
                CreateRemoveBlog();

            // Only one version of data is in the cache.
            Assert.AreEqual(1, _cache.GetSize());
            Assert.AreEqual(1, _metaCache.GetSize());
        }

        /// <summary>
        /// Tests the old entries cleanup in multi threaded scenario.
        /// </summary>
        [Test]
        [Category(TestUtils.CategoryIntensive)]
        public void TestOldEntriesCleanupMultithreaded()
        {
            TestUtils.RunMultiThreaded(CreateRemoveBlog, 4, 5);

            // Run once again to force cleanup.
            CreateRemoveBlog();

            // Wait for the cleanup to complete.
            Thread.Sleep(1000);

            // Only one version of data is in the cache.
            Assert.AreEqual(1, _cache.GetSize());
            Assert.AreEqual(1, _metaCache.GetSize());
        }

        /// <summary>
        /// Tests the entity set version increment in multi-threaded scenario.
        /// </summary>
        [Test]
        [Category(TestUtils.CategoryIntensive)]
        public void TestIncrementMultithreaded()
        {
            var opCnt = 0;

            TestUtils.RunMultiThreaded(() =>
            {
                var blog = new Blog {Name = "my blog"};
                using (var ctx = GetDbContext())
                {
                    ctx.Blogs.Add(blog);
                    ctx.SaveChanges();
                }

                Interlocked.Increment(ref opCnt);

                using (var ctx = GetDbContext())
                {
                    ctx.Blogs.Attach(blog);
                    ctx.Blogs.Remove(blog);
                    ctx.SaveChanges();
                }

                Interlocked.Increment(ref opCnt);
            }, 4, 5);

            var setVersion = _metaCache["Blog"];

            Assert.AreEqual(opCnt, setVersion);
        }

        /// <summary>
        /// Creates and removes a blog.
        /// </summary>
        private void CreateRemoveBlog()
        {
            try
            {
                CreateRemoveBlog0();
            }
            catch (Exception ex)
            {
                // Ignore SQL CE glitch.
                if (!ex.ToString().Contains("The current row was deleted."))
                    throw;
            }
        }

        /// <summary>
        /// Creates and removes a blog.
        /// </summary>
        private void CreateRemoveBlog0()
        {
            var blog = new Blog {Name = "my blog"};
            var threadId = Thread.CurrentThread.ManagedThreadId;

            Func<object> getMeta = () => _metaCache.Where(x => x.Key.Equals("Blog"))
                .Select(x => x.Value).SingleOrDefault() ?? "null";

            var meta1 = getMeta();

            using (var ctx = GetDbContext())
            {
                ctx.Blogs.Add(blog);
                ctx.SaveChanges();
            }

            var meta2 = getMeta();

            using (var ctx = GetDbContext())
            {
                // Use ToArray so that there is always the same DB query.
                Assert.AreEqual(1, ctx.Blogs.ToArray().Count(x => x.BlogId == blog.BlogId),
                    string.Format("Existing blog not found: {0} = {1}, {2} | {3}", blog.BlogId, meta1, meta2, 
                    threadId));
            }

            var meta3 = getMeta();

            using (var ctx = GetDbContext())
            {
                ctx.Blogs.Attach(blog);
                ctx.Blogs.Remove(blog);
                ctx.SaveChanges();
            }

            var meta4 = getMeta();

            using (var ctx = GetDbContext())
            {
                // Use ToArray so that there is always the same DB query.
                Assert.AreEqual(0, ctx.Blogs.ToArray().Count(x => x.BlogId == blog.BlogId),
                    string.Format("Found removed blog: {0} = {1}, {2}, {3}, {4} | {5}", blog.BlogId, meta1, 
                    meta2, meta3, meta4, threadId));
            }
        }

        /// <summary>
        /// Executes the entity SQL.
        /// </summary>
        private static EntityCommand GetEntityCommand(IObjectContextAdapter ctx, string esql)
        {
            var objCtx = ctx.ObjectContext;

            var conn = objCtx.Connection;
            conn.Open();

            var cmd = (EntityCommand) conn.CreateCommand();
            cmd.CommandText = esql;

            return cmd;
        }

        /// <summary>
        /// Gets the test entity.
        /// </summary>
        private static ArrayReaderTest GetTestEntity()
        {
            return new ArrayReaderTest
            {
                DateTime = DateTime.Today,
                Bool = true,
                Byte = 56,
                String = "z",
                Decimal = (decimal)5.6,
                Double = 7.8d,
                Float = -4.5f,
                Guid = Guid.NewGuid(),
                ArrayReaderTestId = -8,
                Long = 3,
                Short = 5
            };
        }

        /// <summary>
        /// Gets the database context.
        /// </summary>
        private static BloggingContext GetDbContext()
        {
            return new BloggingContext(ConnectionString);
        }

        private class MyDbConfiguration : IgniteDbConfiguration
        {
            public MyDbConfiguration() : base(Ignition.GetIgnite(), null, null, Policy)
            {
                var ex = Assert.Throws<ArgumentException>(() => InitializeIgniteCaching(
                    this, Ignition.GetIgnite(), null, null, Policy));

                Assert.IsTrue(ex.Message.StartsWith("'dbConfiguration' argument is invalid: " +
                                                    "IgniteDbConfiguration.InitializeIgniteCaching should not " +
                                                    "be called for IgniteDbConfiguration instance."), ex.Message);
            }
        }

        [DbConfigurationType(typeof(MyDbConfiguration))]
        private class BloggingContext : DbContext
        {
            public BloggingContext(string nameOrConnectionString) : base(nameOrConnectionString)
            {
                // No-op.
            }

            public virtual DbSet<Blog> Blogs { get; set; }
            public virtual DbSet<Post> Posts { get; set; }
            public virtual DbSet<ArrayReaderTest> Tests { get; set; }
        }

        private class Blog
        {
            public int BlogId { get; set; }
            public string Name { get; set; }

            public virtual List<Post> Posts { get; set; }
        }

        private class Post
        {
            public int PostId { get; set; }
            public string Title { get; set; }
            public string Content { get; set; }

            public int BlogId { get; set; }
            public virtual Blog Blog { get; set; }
        }

        private class ArrayReaderTest
        {
            public byte Byte { get; set; }
            public short Short { get; set; }
            public int ArrayReaderTestId { get; set; }
            public long Long { get; set; }
            public float Float { get; set; }
            public double Double { get; set; }
            public decimal Decimal { get; set; }
            public bool Bool { get; set; }
            public string String { get; set; }
            public Guid Guid { get; set; }
            public DateTime DateTime { get; set; }

            private bool Equals(ArrayReaderTest other)
            {
                return Byte == other.Byte && Short == other.Short &&
                       ArrayReaderTestId == other.ArrayReaderTestId && Long == other.Long && 
                       Float.Equals(other.Float) && Double.Equals(other.Double) && 
                       Decimal == other.Decimal && Bool == other.Bool && String == other.String && 
                       Guid.Equals(other.Guid) && DateTime.Equals(other.DateTime);
            }

            public override bool Equals(object obj)
            {
                if (ReferenceEquals(null, obj)) return false;
                if (ReferenceEquals(this, obj)) return true;
                if (obj.GetType() != GetType()) return false;
                return Equals((ArrayReaderTest) obj);
            }

            public override int GetHashCode()
            {
                unchecked
                {
                    var hashCode = Byte.GetHashCode();
                    hashCode = (hashCode*397) ^ Short.GetHashCode();
                    hashCode = (hashCode*397) ^ ArrayReaderTestId;
                    hashCode = (hashCode*397) ^ Long.GetHashCode();
                    hashCode = (hashCode*397) ^ Float.GetHashCode();
                    hashCode = (hashCode*397) ^ Double.GetHashCode();
                    hashCode = (hashCode*397) ^ Decimal.GetHashCode();
                    hashCode = (hashCode*397) ^ Bool.GetHashCode();
                    hashCode = (hashCode*397) ^ String.GetHashCode();
                    hashCode = (hashCode*397) ^ Guid.GetHashCode();
                    hashCode = (hashCode*397) ^ DateTime.GetHashCode();
                    return hashCode;
                }
            }
        }

        private class DelegateCachingPolicy : DbCachingPolicy
        {
            public Func<DbQueryInfo, bool> CanBeCachedFunc { get; set; }

            public Func<DbQueryInfo, int, bool> CanBeCachedRowsFunc { get; set; }

            public Func<DbQueryInfo, TimeSpan> GetExpirationTimeoutFunc { get; set; }

            public Func<DbQueryInfo, DbCachingMode> GetCachingStrategyFunc { get; set; }

            public override bool CanBeCached(DbQueryInfo queryInfo)
            {
                return CanBeCachedFunc == null || CanBeCachedFunc(queryInfo);
            }

            public override bool CanBeCached(DbQueryInfo queryInfo, int rowCount)
            {
                return CanBeCachedRowsFunc == null || CanBeCachedRowsFunc(queryInfo, rowCount);
            }

            public override TimeSpan GetExpirationTimeout(DbQueryInfo queryInfo)
            {
                return GetExpirationTimeoutFunc == null 
                    ? base.GetExpirationTimeout(queryInfo) 
                    : GetExpirationTimeoutFunc(queryInfo);
            }

            public override DbCachingMode GetCachingMode(DbQueryInfo queryInfo)
            {
                return GetCachingStrategyFunc == null 
                    ? base.GetCachingMode(queryInfo)
                    : GetCachingStrategyFunc(queryInfo);
            }
        }
    }
}