示例#1
0
        public async Task Can_Add_Database_Folder_With_Side_By_Side_Indexes(string indexName)
        {
            var path = NewDataPath();

            using (var store = GetDocumentStore(new Options
            {
                RunInMemory = false,
                Path = path
            }))
            {
                using (var session = store.OpenAsyncSession())
                {
                    await session.StoreAsync(new Order());

                    await session.SaveChangesAsync();
                }

                var index1 = new Index1(indexName);
                await index1.ExecuteAsync(store);

                await new Index2(indexName).ExecuteAsync(store);

                Indexes.WaitForIndexing(store, allowErrors: true, timeout: TimeSpan.FromSeconds(5));

                var record = await store.Maintenance.Server.SendAsync(new GetDatabaseRecordOperation(store.Database));

                Assert.Equal(1, record.Indexes.Count);
                Assert.Equal(index1.IndexName, record.Indexes.First().Key);

                var indexStats = await store.Maintenance.SendAsync(new GetIndexesStatisticsOperation());

                Assert.Equal(2, indexStats.Length);

                await store.Maintenance.Server.SendAsync(new DeleteDatabasesOperation(store.Database, hardDelete : false));

                await store.Maintenance.Server.SendAsync(new CreateDatabaseOperation(new DatabaseRecord(store.Database)
                {
                    Settings =
                    {
                        { RavenConfiguration.GetKey(x => x.Core.RunInMemory),   "false" },
                        { RavenConfiguration.GetKey(x => x.Core.DataDirectory), path    }
                    }
                }));

                record = await store.Maintenance.Server.SendAsync(new GetDatabaseRecordOperation(store.Database));

                Assert.Equal(index1.IndexName, record.Indexes.First().Key);
                Assert.Contains("Count = 1 / this0.x", record.Indexes.First().Value.Maps.First());

                // replacing with another index with another index with an error
                await new Index3(indexName).ExecuteAsync(store);
                Indexes.WaitForIndexing(store, allowErrors: true, timeout: TimeSpan.FromSeconds(5));

                var database = await GetDatabase(store.Database);

                var index = database.IndexStore.GetIndex($"{Constants.Documents.Indexing.SideBySideIndexNamePrefix}{indexName}");
                Assert.Contains("Count = 5 / this0.x", index.GetIndexDefinition().Maps.First());

                // an index with no errors will replace both the original and the replacement
                var index4 = new Index4(indexName);
                await new Index4(indexName).ExecuteAsync(store);
                Indexes.WaitForIndexing(store);

                index = database.IndexStore.GetIndex(indexName);
                Assert.Contains("New_Count = 5", index.GetIndexDefinition().Maps.First());

                using (var session = store.OpenAsyncSession())
                {
                    var results = await session.Query <Index4.Result>(index4.IndexName)
                                  .Where(x => x.New_Count == 5)
                                  .ToListAsync();

                    Assert.Equal(1, results.Count);
                }
            }
        }