public void SideBySideIndexCreated()
{
using (var store = NewDocumentStore())
{
IndexCreation.CreateIndexes(new CompositionContainer(new TypeCatalog(typeof(OldIndex))), store);
WaitForIndexing(store);
var e = Assert.Throws <InvalidOperationException>(() =>
{
using (var session = store.OpenSession())
{
var count = session.Query <Person, OldIndex>()
.Count(x => x.LastName == "Doe");
}
});
Assert.Contains("The field 'LastName' is not indexed, cannot query on fields that are not indexed", e.InnerException.Message);
var mre = new ManualResetEventSlim(false);
var documentDatabase = store.ServerIfEmbedded.Server.GetDatabaseInternal(store.DefaultDatabase).Result;
documentDatabase.IndexReplacer.IndexReplaced += s =>
{
mre.Set();
};
IndexCreation.SideBySideCreateIndexes(new CompositionContainer(new TypeCatalog(typeof(NewIndex))), store);
WaitForUserToContinueTheTest(store);
Assert.True(mre.Wait(10000));
Assert.Equal(2, store.DatabaseCommands.GetStatistics().CountOfIndexes);
}
}
public void can_use_conventions_with_create_side_by_side_indexes_container()
{
using (var store = NewDocumentStore())
{
var container = new CompositionContainer(new TypeCatalog(typeof(CustomIdInIndexCreationTask)));
IndexCreation.SideBySideCreateIndexes(container, store.DatabaseCommands, conventions);
Assert.True(testFailed == false);
}
}
public void should_not_reset_lock_mode_on_multiple_side_by_side_index_creation()
{
using (var documentStore = NewDocumentStore())
{
var container = new CompositionContainer(new TypeCatalog(typeof(Entity_ById_V1)));
IndexCreation.SideBySideCreateIndexes(container, documentStore.DatabaseCommands, documentStore.Conventions);
WaitForIndexing(documentStore);
documentStore.DatabaseCommands.SetIndexLock("Entity/ById", IndexLockMode.SideBySide);
var databaseStatisticsBefore = documentStore.DatabaseCommands.GetStatistics();
var indexStatsBefore = databaseStatisticsBefore.Indexes.Single(i => i.Name == "Entity/ById");
Assert.Equal(2, databaseStatisticsBefore.Indexes.Length);
Assert.Equal(IndexLockMode.SideBySide, indexStatsBefore.LockMode);
while (true)
{
var index = documentStore.DatabaseCommands.GetStatistics().Indexes.FirstOrDefault(x => x.Name == "Entity/ById");
if (index != null)
{
break;
}
Thread.Sleep(100);
}
container = new CompositionContainer(new TypeCatalog(typeof(Entity_ById_V2)));
IndexCreation.SideBySideCreateIndexes(container, documentStore.DatabaseCommands, documentStore.Conventions);
WaitForIndexing(documentStore);
while (documentStore.DatabaseCommands.GetStatistics().Indexes.Length != 2)
{
Thread.Sleep(100);
}
var databaseStatisticsAfter = documentStore.DatabaseCommands.GetStatistics();
var indexStatsAfter = databaseStatisticsAfter.Indexes.Single(i => i.Name == "Entity/ById");
Assert.Equal(2, databaseStatisticsAfter.Indexes.Length);
Assert.Equal(IndexLockMode.SideBySide, indexStatsAfter.LockMode);
}
}
public void ReplaceAfterNonStale()
{
using (var store = NewDocumentStore())
{
IndexCreation.CreateIndexes(new CompositionContainer(new TypeCatalog(typeof(OldIndex))), store);
WaitForIndexing(store);
var e = Assert.Throws <InvalidOperationException>(() =>
{
using (var session = store.OpenSession())
{
var count = session.Query <Person, OldIndex>()
.Count(x => x.LastName == "Doe");
}
});
Assert.Contains("The field 'LastName' is not indexed, cannot query on fields that are not indexed", e.InnerException.Message);
IndexCreation.SideBySideCreateIndexes(new CompositionContainer(new TypeCatalog(typeof(NewIndex))), store);
WaitForIndexing(store);
var indexReplaceDocId = Constants.IndexReplacePrefix + "ReplacementOf/" + new NewIndex().IndexName;
Assert.True(SpinWait.SpinUntil(() => store.DatabaseCommands.Get(indexReplaceDocId) == null, TimeSpan.FromSeconds(30))); // wait for index replacement
using (var session = store.OpenSession())
{
var count = session.Query <Person, OldIndex>()
.Count(x => x.LastName == "Doe");
Assert.Equal(0, count);
}
}
}
public void ShouldNotReplaceIndexIfSameDefinition()
{
using (var store = NewDocumentStore())
{
IndexCreation.CreateIndexes(new CompositionContainer(new TypeCatalog(typeof(OldIndex))), store);
WaitForIndexing(store);
var e = Assert.Throws <InvalidOperationException>(() =>
{
using (var session = store.OpenSession())
{
var count = session.Query <Person, OldIndex>()
.Count(x => x.LastName == "Doe");
}
});
var error = "The field 'LastName' is not indexed, cannot query on fields that are not indexed";
Assert.Contains(error, e.InnerException.Message);
IndexCreation.SideBySideCreateIndexes(new CompositionContainer(new TypeCatalog(typeof(OldIndex))), store);
WaitForIndexing(store);
Assert.Equal(2, store.DatabaseCommands.GetStatistics().CountOfIndexes);
e = Assert.Throws <InvalidOperationException>(() =>
{
using (var session = store.OpenSession())
{
var count = session.Query <Person, OldIndex>()
.Count(x => x.LastName == "Doe");
}
});
Assert.Contains("The field 'LastName' is not indexed, cannot query on fields that are not indexed", e.InnerException.Message);
}
}
