Пример #1
0
        public void SmugglerBetweenOperationShouldNotCreateDatabases()
        {
            using (var store = NewRemoteDocumentStore())
            {
                var smugglerApi = new SmugglerDatabaseApi();

                var options = new SmugglerBetweenOptions <RavenConnectionStringOptions>
                {
                    From = new RavenConnectionStringOptions
                    {
                        Url             = store.Url,
                        DefaultDatabase = "DB1"
                    },
                    To = new RavenConnectionStringOptions
                    {
                        Url             = store.Url,
                        DefaultDatabase = "DB2"
                    }
                };

                var aggregateException = Assert.Throws <AggregateException>(() => smugglerApi.Between(options).Wait());
                var exception          = aggregateException.ExtractSingleInnerException();
                Assert.True(exception.Message.StartsWith("Smuggler does not support database creation (database 'DB1' on server"));

                store.DatabaseCommands.GlobalAdmin.EnsureDatabaseExists("DB1");

                aggregateException = Assert.Throws <AggregateException>(() => smugglerApi.Between(options).Wait());
                exception          = aggregateException.ExtractSingleInnerException();
                Assert.True(exception.Message.StartsWith("Smuggler does not support database creation (database 'DB2' on server"));
            }
        }
Пример #2
0
        public async void Sample2()
        {
            #region smuggler_api_3
            // export Documents and Indexes
            // from Northwind database
            // found on http://localhost:8080
            // and import them to NewNorthwind
            // found on the same server
            SmugglerDatabaseApi smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions
            {
                OperateOnTypes = ItemType.Documents | ItemType.Indexes,
                Incremental    = false
            });

            await smugglerApi.Between(
                new SmugglerBetweenOptions <RavenConnectionStringOptions>
            {
                From = new RavenConnectionStringOptions
                {
                    Url             = "http://localhost:8080",
                    DefaultDatabase = "Northwind"
                },
                To = new RavenConnectionStringOptions
                {
                    Url             = "http://localhost:8080",
                    DefaultDatabase = "NewNorthwind"
                }
            });

            #endregion
        }
Пример #3
0
        public async Task ShouldWork()
        {
            using (var server1 = GetNewServer(port: 8079))
                using (var store1 = NewRemoteDocumentStore(ravenDbServer: server1, databaseName: "Database1"))
                {
                    await new UsersIndex().ExecuteAsync(store1.AsyncDatabaseCommands, new DocumentConvention());
                    await new UsersTransformer().ExecuteAsync(store1);
                    using (var session = store1.OpenAsyncSession("Database1"))
                    {
                        await session.StoreAsync(new User { Name = "Oren Eini" });

                        await session.StoreAsync(new User { Name = "Fitzchak Yitzchaki" });

                        await session.SaveChangesAsync();
                    }
                    await store1.AsyncDatabaseCommands.PutAttachmentAsync("ayende", null, new MemoryStream(new byte[] { 3 }), new RavenJObject());

                    await store1.AsyncDatabaseCommands.PutAttachmentAsync("fitzchak", null, new MemoryStream(new byte[] { 2 }), new RavenJObject());

                    using (var server2 = GetNewServer(port: 8078))
                    {
                        using (var store2 = NewRemoteDocumentStore(ravenDbServer: server2, databaseName: "Database2"))
                        {
                            var smugglerApi = new SmugglerDatabaseApi();
                            await smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>
                            {
                                From = new RavenConnectionStringOptions {
                                    Url = "http://localhost:8079", DefaultDatabase = "Database1"
                                },
                                To = new RavenConnectionStringOptions {
                                    Url = "http://localhost:8078", DefaultDatabase = "Database2"
                                }
                            });

                            await AssertDatabaseHasIndex <UsersIndex>(store2);
                            await AssertDatabaseHasTransformer <UsersTransformer>(store2);

                            using (var session2 = store2.OpenAsyncSession("Database2"))
                            {
                                Assert.Equal(2, await session2.Query <User>().CountAsync());
                            }

                            var attachments = await store2.AsyncDatabaseCommands.GetAttachmentsAsync(0, Etag.Empty, 25);

                            Assert.Equal(2, attachments.Length);
                            Assert.Equal("ayende", attachments[0].Key);
                            Assert.Equal("fitzchak", attachments[1].Key);
                        }
                    }
                }
        }
Пример #4
0
        public async Task Filtering_between_with_subscriptions_should_work()
        {
            using (var serverFrom = GetNewServer(8090))
                using (var serverTo = GetNewServer(8091))
                    using (var from = NewRemoteDocumentStore(ravenDbServer: serverFrom))
                        using (var to = NewRemoteDocumentStore(ravenDbServer: serverTo))
                        {
                            using (var session = from.OpenSession())
                            {
                                session.Store(new { Foo = "Bar" }, "foo/bar");
                                session.SaveChanges();
                            }

                            from.Subscriptions.Create(new SubscriptionCriteria
                            {
                                KeyStartsWith = "foo/b"
                            });

                            var filters = new FilterSetting
                            {
                                Values = new[] { "Raven/Subscriptions" }.ToList(),
                                ShouldMatch = false,
                                Path        = "@name"
                            };

                            var smuggler = new SmugglerDatabaseApi(
                                new SmugglerDatabaseOptions
                            {
                                Incremental     = false,
                                Filters         = new[] { filters }.ToList(),
                                TransformScript = null,
                            });

                            await smuggler.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>
                            {
                                From = new RavenConnectionStringOptions
                                {
                                    Url             = from.Url,
                                    DefaultDatabase = from.DefaultDatabase
                                },
                                To = new RavenConnectionStringOptions
                                {
                                    Url             = to.Url,
                                    DefaultDatabase = to.DefaultDatabase
                                }
                            });
                        }
        }
Пример #5
0
        public async Task Using_smuggler_between_servers_should_take_into_accound_files_related_while_smuggling()
        {
            using (var server1 = GetNewServer(8090))
                using (var server2 = GetNewServer(8091))
                    using (var store1 = NewRemoteDocumentStore(ravenDbServer: server1))
                        using (var store2 = NewRemoteDocumentStore(ravenDbServer: server2))
                        {
                            var smugglerApi = new SmugglerDatabaseApi();

                            var createdUsers = AddDocuments(store1);
                            var users        = new ConcurrentBag <User>();
                            foreach (var user in createdUsers)
                            {
                                users.Add(user);
                            }

                            var addDocsTask = Task.Run(() =>
                            {
                                var createdUsersInParallel = AddDocuments(store1);
                                foreach (var user in createdUsersInParallel)
                                {
                                    users.Add(user);
                                }
                            });
                            var smugglingTask = smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>
                            {
                                From = new RavenConnectionStringOptions
                                {
                                    Url             = store1.Url,
                                    DefaultDatabase = store1.DefaultDatabase
                                },
                                To = new RavenConnectionStringOptions
                                {
                                    Url             = store2.Url,
                                    DefaultDatabase = store2.DefaultDatabase
                                }
                            });

                            await smugglingTask;
                            await addDocsTask; //not necessary -> smuggling task should effectively do this as well

                            WaitForIndexing(store2);
                            using (var session = store2.OpenSession())
                                Assert.Equal(users.Count, session.Query <User>().Count());
                        }
        }
Пример #6
0
        public async Task ShouldSmuggleIdentitiesBetweenDatabases()
        {
            using (var server1 = GetNewServer(port: 8079))
                using (var store1 = NewRemoteDocumentStore(ravenDbServer: server1, databaseName: "Database1"))
                {
                    using (var session = store1.OpenAsyncSession("Database1"))
                    {
                        await session.StoreAsync(new User { Id = "users/", Name = "Arek" });

                        await session.SaveChangesAsync();
                    }

                    store1.DatabaseCommands.SeedIdentityFor("users/", 10);

                    using (var server2 = GetNewServer(port: 8078))
                    {
                        using (var store2 = NewRemoteDocumentStore(ravenDbServer: server2, databaseName: "Database2"))
                        {
                            var smugglerApi = new SmugglerDatabaseApi();
                            await smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>
                            {
                                From = new RavenConnectionStringOptions {
                                    Url = "http://localhost:8079", DefaultDatabase = "Database1"
                                },
                                To = new RavenConnectionStringOptions {
                                    Url = "http://localhost:8078", DefaultDatabase = "Database2"
                                }
                            });

                            using (var session = store2.OpenAsyncSession("Database2"))
                            {
                                await session.StoreAsync(new User { Id = "users/", Name = "Oren" });

                                await session.SaveChangesAsync();
                            }

                            var documents = (await store2.AsyncDatabaseCommands.GetDocumentsAsync(0, 10)).OrderBy(x => x.Key).ToArray();

                            Assert.Equal(2, documents.Length);
                            Assert.Equal("users/1", documents[0].Key);
                            Assert.Equal("users/11", documents[1].Key);
                        }
                    }
                }
        }
Пример #7
0
        public async Task CanUseBetween()
        {
            using (var server1 = new RavenDbServer(new RavenConfiguration()
            {
                Port = Port1,
                ServerName = ServerName1
            })
            {
                RunInMemory = true,
                UseEmbeddedHttpServer = true
            }.Initialize())
            {
                var doc = MultiDatabase.CreateDatabaseDocument("db1");
                ((ServerClient)server1.DocumentStore.DatabaseCommands.ForSystemDatabase()).GlobalAdmin.CreateDatabase(doc);

                using (var store1 = new DocumentStore
                {
                    Url = "http://localhost:" + Port1,
                    DefaultDatabase = "db1"
                }.Initialize())
                {
                    new Users_ByName().Execute(store1);
                    new UsersTransformer().Execute(store1);

                    using (var session = store1.OpenSession("db1"))
                    {
                        session.Store(new User {
                            Name = "Name1", LastName = "LastName1"
                        });
                        session.Store(new User {
                            Name = "Name2", LastName = "LastName2"
                        });
                        session.SaveChanges();
                    }

                    store1.DatabaseCommands.PutAttachment("attachement1", null, new MemoryStream(new byte[] { 3 }), new RavenJObject());

                    using (var server2 = new RavenDbServer(new RavenConfiguration()
                    {
                        Port = Port2,
                        ServerName = ServerName2
                    })
                    {
                        RunInMemory = true,
                        UseEmbeddedHttpServer = true
                    }.Initialize())
                    {
                        var doc2 = MultiDatabase.CreateDatabaseDocument("db2");
                        ((ServerClient)server2.DocumentStore.DatabaseCommands.ForSystemDatabase()).GlobalAdmin.CreateDatabase(doc2);

                        using (var store2 = new DocumentStore
                        {
                            Url = "http://localhost:" + Port2,
                            DefaultDatabase = "db2"
                        }.Initialize())
                        {
                            var smugglerApi = new SmugglerDatabaseApi();
                            await smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>
                            {
                                From = new RavenConnectionStringOptions {
                                    Url = "http://localhost:" + Port1, DefaultDatabase = "db1"
                                },
                                To = new RavenConnectionStringOptions {
                                    Url = "http://localhost:" + Port2, DefaultDatabase = "db2"
                                }
                            });

                            var docs = store2.DatabaseCommands.GetDocuments(0, 10);
                            Assert.Equal(3, docs.Length);
                            var indexes = store2.DatabaseCommands.GetIndexes(0, 10);
                            Assert.Equal(1, indexes.Length);
                            var transformers = store2.DatabaseCommands.GetTransformers(0, 10);
                            Assert.Equal(1, transformers.Length);
                            var attachments = store2.DatabaseCommands.GetAttachments(0, new Etag(), 10);
                            Assert.Equal(1, attachments.Length);
                        }
                    }
                }
            }
        }
Пример #8
0
        public async Task Smuggler_filtering_next_etag()
        {
            using (var server = GetNewServer())
            {
                using (var store = new DocumentStore {
                    Url = server.SystemDatabase.Configuration.ServerUrl
                }.Initialize())
                {
                    store
                    .DatabaseCommands
                    .GlobalAdmin
                    .CreateDatabase(new DatabaseDocument
                    {
                        Id       = "Dba1",
                        Settings =
                        {
                            { "Raven/DataDir", "Dba1" }
                        }
                    });
                    store.DatabaseCommands.EnsureDatabaseExists("Dba1");

                    store
                    .DatabaseCommands
                    .GlobalAdmin
                    .CreateDatabase(new DatabaseDocument
                    {
                        Id       = "Dba2",
                        Settings =
                        {
                            { "Raven/DataDir", "Dba2" }
                        }
                    });
                    store.DatabaseCommands.EnsureDatabaseExists("Dba2");
                }
                using (var store1 = new DocumentStore
                {
                    Url = server.SystemDatabase.Configuration.ServerUrl,
                    DefaultDatabase = "Dba1"
                }.Initialize())
                {
                    StoreWorkerseDba1(store1);
                    using (var session = store1.OpenSession())
                    {
                        var workers = session.Query <Worker>().ToList();
                        Assert.Equal(3, workers.Count);

                        var index1 = store1.DatabaseCommands.GetIndex("WorkerByName");
                        var index2 = store1.DatabaseCommands.GetIndex("WorkerByAge");
                        var index3 = store1.DatabaseCommands.GetIndex("WorkerAccountNumber");
                        Assert.Equal("WorkerByName", index1.Name);
                        Assert.Equal("WorkerByAge", index2.Name);
                        Assert.Equal("WorkerAccountNumber", index3.Name);
                    }
                }

                SmugglerDatabaseApi smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions
                {
                    OperateOnTypes = ItemType.Documents | ItemType.Indexes,
                    Incremental    = false
                });
                smugglerApi.Options.Filters.Add(new FilterSetting
                {
                    Path        = "Name",
                    ShouldMatch = true,
                    Values      = { "worker/22", "worker/333" }
                });

                await smugglerApi.Between(
                    new SmugglerBetweenOptions <RavenConnectionStringOptions>
                {
                    From = new RavenConnectionStringOptions
                    {
                        Url             = server.SystemDatabase.Configuration.ServerUrl,
                        DefaultDatabase = "Dba1"
                    },
                    To = new RavenConnectionStringOptions
                    {
                        Url             = server.SystemDatabase.Configuration.ServerUrl,
                        DefaultDatabase = "Dba2"
                    }
                });

                using (var store2 = new DocumentStore
                {
                    Url = server.SystemDatabase.Configuration.ServerUrl,
                    DefaultDatabase = "Dba2"
                }.Initialize())
                {
                    using (var session = store2.OpenSession())
                    {
                        var workers = session.Query <Worker>().ToList();
                        Assert.Equal(0, workers.Count);
                        var index1 = store2.DatabaseCommands.GetIndex("WorkerByName");
                        var index2 = store2.DatabaseCommands.GetIndex("WorkerByAge");
                        var index3 = store2.DatabaseCommands.GetIndex("WorkerAccountNumber");
                        Assert.Equal("WorkerByName", index1.Name);
                        Assert.Equal("WorkerByAge", index2.Name);
                        Assert.Equal("WorkerAccountNumber", index3.Name);
                    }
                }
            }
        }
Пример #9
0
        public async Task ShouldSupportIncremental()
        {
            using (var server1 = GetNewServer(port: 8079))
                using (var store1 = NewRemoteDocumentStore(ravenDbServer: server1, databaseName: "Database1"))
                {
                    using (var session = store1.OpenAsyncSession("Database1"))
                    {
                        await session.StoreAsync(new User { Name = "Oren Eini" });

                        await session.StoreAsync(new User { Name = "Fitzchak Yitzchaki" });

                        await session.SaveChangesAsync();
                    }
                    await store1.AsyncDatabaseCommands.PutAttachmentAsync("ayende", null, new MemoryStream(new byte[] { 3 }), new RavenJObject());

                    await store1.AsyncDatabaseCommands.PutAttachmentAsync("fitzchak", null, new MemoryStream(new byte[] { 2 }), new RavenJObject());

                    using (var server2 = GetNewServer(port: 8078))
                    {
                        using (var store2 = NewRemoteDocumentStore(ravenDbServer: server2, databaseName: "Database2"))
                        {
                            var smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions
                            {
                                Incremental = true,
                            });

                            await smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>
                            {
                                From = new RavenConnectionStringOptions {
                                    Url = "http://localhost:8079", DefaultDatabase = "Database1"
                                },
                                To = new RavenConnectionStringOptions {
                                    Url = "http://localhost:8078", DefaultDatabase = "Database2"
                                }
                            });

                            using (var session = store1.OpenAsyncSession("Database1"))
                            {
                                var oren = await session.LoadAsync <User>("users/1");

                                oren.Name += " Changed";
                                await session.StoreAsync(new User { Name = "Daniel Dar" });

                                await session.SaveChangesAsync();
                            }
                            await store1.AsyncDatabaseCommands.PutAttachmentAsync("ayende", null, new MemoryStream(new byte[] { 4 }), new RavenJObject());

                            await store1.AsyncDatabaseCommands.PutAttachmentAsync("daniel", null, new MemoryStream(new byte[] { 5 }), new RavenJObject());

                            using (var session2 = store2.OpenAsyncSession("Database2"))
                            {
                                var oren = await session2.LoadAsync <User>("users/2");

                                oren.Name += " Not Changed";
                                await session2.SaveChangesAsync();
                            }
                            await store2.AsyncDatabaseCommands.PutAttachmentAsync("fitzchak", null, new MemoryStream(new byte[] { 6 }), new RavenJObject());

                            await smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>
                            {
                                From = new RavenConnectionStringOptions {
                                    Url = "http://localhost:8079", DefaultDatabase = "Database1"
                                },
                                To = new RavenConnectionStringOptions {
                                    Url = "http://localhost:8078", DefaultDatabase = "Database2"
                                }
                            });

                            using (var session2 = store2.OpenAsyncSession("Database2"))
                            {
                                Assert.Equal(3, await session2.Query <User>().CountAsync());
                                Assert.Equal("Oren Eini Changed", (await session2.LoadAsync <User>("users/1")).Name);
                                Assert.Equal("Fitzchak Yitzchaki Not Changed", (await session2.LoadAsync <User>("users/2")).Name); // Test that this value won't be overwritten by the export server
                            }

                            Assert.Equal(3, (await store2.AsyncDatabaseCommands.GetAttachmentsAsync(0, Etag.Empty, 25)).Length);
                            await AssertAttachmentContent(store2, "ayende", new byte[] { 4 });
                            await AssertAttachmentContent(store2, "fitzchak", new byte[] { 6 }); // Test that this value won't be overwritten by the export server
                        }
                    }
                }
        }
Пример #10
0
        public async Task ShouldSupportIncrementalFromTwoServers()
        {
            using (var server1 = GetNewServer(port: 8079))
                using (var store1 = NewRemoteDocumentStore(ravenDbServer: server1, databaseName: "Database1"))
                {
                    using (var session = store1.OpenAsyncSession("Database1"))
                    {
                        await session.StoreAsync(new User { Name = "Oren Eini" });

                        await session.StoreAsync(new User { Name = "Fitzchak Yitzchaki" });

                        await session.SaveChangesAsync();
                    }
                    await store1.AsyncDatabaseCommands.PutAttachmentAsync("ayende", null, new MemoryStream(new byte[] { 13 }), new RavenJObject());

                    await store1.AsyncDatabaseCommands.PutAttachmentAsync("fitzchak", null, new MemoryStream(new byte[] { 12 }), new RavenJObject());

                    using (var server2 = GetNewServer(port: 8078))
                        using (var store2 = NewRemoteDocumentStore(ravenDbServer: server2, databaseName: "Database2"))
                        {
                            using (var session = store2.OpenAsyncSession("Database2"))
                            {
                                await session.StoreAsync(new User { Name = "Oren Eini Server 2" });

                                await session.SaveChangesAsync();
                            }
                            await store2.AsyncDatabaseCommands.PutAttachmentAsync("ayende", null, new MemoryStream(new byte[] { 23 }), new RavenJObject());

                            using (var server3 = GetNewServer(port: 8077))
                            {
                                using (var store3 = NewRemoteDocumentStore(ravenDbServer: server3, databaseName: "Database3"))
                                {
                                    var smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions
                                    {
                                        Incremental = true,
                                    });

                                    await smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>
                                    {
                                        From = new RavenConnectionStringOptions {
                                            Url = "http://localhost:8079", DefaultDatabase = "Database1"
                                        },
                                        To = new RavenConnectionStringOptions {
                                            Url = "http://localhost:8077", DefaultDatabase = "Database3"
                                        }
                                    });

                                    await smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>
                                    {
                                        From = new RavenConnectionStringOptions {
                                            Url = "http://localhost:8078", DefaultDatabase = "Database2"
                                        },
                                        To = new RavenConnectionStringOptions {
                                            Url = "http://localhost:8077", DefaultDatabase = "Database3"
                                        }
                                    });

                                    using (var session3 = store3.OpenAsyncSession("Database3"))
                                    {
                                        Assert.Equal(2, await session3.Query <User>().CountAsync());
                                        Assert.Equal("Oren Eini Server 2", (await session3.LoadAsync <User>("users/1")).Name);
                                        Assert.Equal("Fitzchak Yitzchaki", (await session3.LoadAsync <User>("users/2")).Name);                    // Test that the value from Database1 is there
                                    }

                                    Assert.Equal(2, (await store3.AsyncDatabaseCommands.GetAttachmentsAsync(0, Etag.Empty, 25)).Length);
                                    await AssertAttachmentContent(store3, "ayende", new byte[] { 23 });
                                    await AssertAttachmentContent(store3, "fitzchak", new byte[] { 12 });               // Test that the value from Database1 is there
                                }
                            }
                        }
                }
        }
Пример #11
0
        public async Task ShouldImportHiloWhenRavenEntityNameFilterIsUsed_Between()
        {
            using (var store1 = CreateStore())
                using (var store2 = CreateStore())
                {
                    using (var session = store1.OpenSession())
                    {
                        session.Store(new Person {
                            Name = "John"
                        });
                        session.Store(new Person {
                            Name = "Edward"
                        });
                        session.Store(new Address {
                            Street = "Main Street"
                        });

                        session.SaveChanges();
                    }

                    using (var stream = new MemoryStream())
                    {
                        var smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions
                        {
                            Filters =
                            {
                                new FilterSetting
                                {
                                    Path        = "@metadata.Raven-Entity-Name",
                                    ShouldMatch = true,
                                    Values      = { "People" }
                                }
                            }
                        });

                        await smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>
                        {
                            From = new RavenConnectionStringOptions
                            {
                                DefaultDatabase = store1.DefaultDatabase,
                                Url             = store1.Url
                            },
                            To = new RavenConnectionStringOptions
                            {
                                DefaultDatabase = store2.DefaultDatabase,
                                Url             = store2.Url
                            }
                        });
                    }

                    WaitForIndexing(store2);

                    using (var session = store2.OpenSession())
                    {
                        var people = session
                                     .Query <Person>()
                                     .ToList();

                        Assert.Equal(2, people.Count);

                        var addresses = session
                                        .Query <Address>()
                                        .ToList();

                        Assert.Equal(0, addresses.Count);

                        var hilo = session.Advanced.DocumentStore.DatabaseCommands.Get("Raven/Hilo/People");
                        Assert.NotNull(hilo);
                    }
                }
        }
Пример #12
0
        public async Task CanDisableVersioningDuringImport_Between_Remote()
        {
            using (var server = GetNewServer())
            {
                using (var store = NewRemoteDocumentStore(ravenDbServer: server))
                {
                    store
                    .DatabaseCommands
                    .GlobalAdmin
                    .CreateDatabase(new DatabaseDocument
                    {
                        Id       = "Import",
                        Settings =
                        {
                            { Constants.ActiveBundles, "Versioning"  },
                            { "Raven/DataDir",         NewDataPath() }
                        }
                    });

                    using (var session = store.OpenSession())
                    {
                        for (int i = 0; i < 10; i++)
                        {
                            session.Store(new User());
                            session.Store(new Address());
                        }

                        session.SaveChanges();
                    }

                    var countOfDocuments = store.DatabaseCommands.GetStatistics().CountOfDocuments;

                    store.DatabaseCommands.ForDatabase("Import").Put("Raven/Versioning/DefaultConfiguration", null, RavenJObject.FromObject(new Bundles.Versioning.Data.VersioningConfiguration
                    {
                        Exclude      = false,
                        Id           = "Raven/Versioning/DefaultConfiguration",
                        MaxRevisions = 5
                    }), new RavenJObject());

                    var smuggler = new SmugglerDatabaseApi(new SmugglerDatabaseOptions()
                    {
                        ShouldDisableVersioningBundle = true
                    });

                    await smuggler.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions>()
                    {
                        From = new RavenConnectionStringOptions()
                        {
                            Url             = store.Url,
                            DefaultDatabase = store.DefaultDatabase
                        },
                        To = new RavenConnectionStringOptions()
                        {
                            Url             = store.Url,
                            DefaultDatabase = "Import"
                        }
                    });

                    var countOfDocsAfterImport = store.DatabaseCommands.ForDatabase("Import").GetStatistics().CountOfDocuments;

                    Assert.Equal(countOfDocuments, countOfDocsAfterImport - 1);                     // one additional doc for versioning bundle configuration

                    var metadata = store.DatabaseCommands.ForDatabase("Import").Get("users/1").Metadata;

                    Assert.True(metadata.ContainsKey(Constants.RavenIgnoreVersioning) == false, "Metadata contains temporary " + Constants.RavenIgnoreVersioning + " marker");

                    // after import versioning should be active
                    using (var session = store.OpenSession("Import"))
                    {
                        session.Store(new User(), "users/arek");

                        session.SaveChanges();

                        var revisionsFor = session.Advanced.GetRevisionsFor <User>("users/arek", 0, 10);

                        Assert.Equal(1, revisionsFor.Length);
                    }
                }
            }
        }