public async Task GetRevisionsBinEntries(bool useSession)
{
using (var store = GetDocumentStore())
{
await RevisionsHelper.SetupRevisions(Server.ServerStore, store.Database, modifyConfiguration : configuration => configuration.Collections["Users"].PurgeOnDelete = false);
var deletedRevisions = await store.Commands().GetRevisionsBinEntriesAsync(long.MaxValue);
Assert.Equal(0, deletedRevisions.Count());
var id = "users/1";
if (useSession)
{
var user = new User {
Name = "Fitzchak"
};
for (var i = 0; i < 2; i++)
{
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(user);
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
session.Delete(user.Id);
await session.SaveChangesAsync();
}
}
id += "-A";
}
else
{
await store.Commands().PutAsync(id, null, new User {
Name = "Fitzchak"
});
await store.Commands().DeleteAsync(id, null);
await store.Commands().PutAsync(id, null, new User {
Name = "Fitzchak"
});
await store.Commands().DeleteAsync(id, null);
}
var statistics = store.Maintenance.Send(new GetStatisticsOperation());
Assert.Equal(useSession ? 1 : 0, statistics.CountOfDocuments);
Assert.Equal(4, statistics.CountOfRevisionDocuments);
deletedRevisions = await store.Commands().GetRevisionsBinEntriesAsync(long.MaxValue);
Assert.Equal(1, deletedRevisions.Count());
using (var session = store.OpenAsyncSession())
{
var users = await session.Advanced.Revisions.GetForAsync <User>(id);
Assert.Equal(4, users.Count);
Assert.Equal(null, users[0].Name);
Assert.Equal("Fitzchak", users[1].Name);
Assert.Equal(null, users[2].Name);
Assert.Equal("Fitzchak", users[3].Name);
// Can get metadata only
var revisionsMetadata = await session.Advanced.Revisions.GetMetadataForAsync(id);
Assert.Equal(4, revisionsMetadata.Count);
Assert.Contains(DocumentFlags.DeleteRevision.ToString(), revisionsMetadata[0].GetString(Constants.Documents.Metadata.Flags));
Assert.Equal((DocumentFlags.HasRevisions | DocumentFlags.Revision).ToString(), revisionsMetadata[1].GetString(Constants.Documents.Metadata.Flags));
Assert.Contains(DocumentFlags.DeleteRevision.ToString(), revisionsMetadata[2].GetString(Constants.Documents.Metadata.Flags));
Assert.Equal((DocumentFlags.HasRevisions | DocumentFlags.Revision).ToString(), revisionsMetadata[3].GetString(Constants.Documents.Metadata.Flags));
}
await store.Maintenance.SendAsync(new DeleteRevisionsOperation(new AdminRevisionsHandler.Parameters
{
DocumentIds = new[] { id, "users/not/exists" }
}));
statistics = store.Maintenance.Send(new GetStatisticsOperation());
Assert.Equal(useSession ? 1 : 0, statistics.CountOfDocuments);
Assert.Equal(0, statistics.CountOfRevisionDocuments);
}
}
public async Task CanGetCountersSnapshotInRevisions()
{
using (var store = GetDocumentStore())
{
await RevisionsHelper.SetupRevisions(Server.ServerStore, store.Database);
using (var session = store.OpenAsyncSession())
{
// revision 1
await session.StoreAsync(new Company(), "companies/1-A");
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var company = await session.LoadAsync <Company>("companies/1-A");
// revision 2
company.Name = "HR";
await session.SaveChangesAsync();
// revision 3
session.CountersFor(company).Increment("Likes", 100);
await session.SaveChangesAsync();
// no revision for this one
session.CountersFor(company).Increment("Likes", 50);
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var companiesRevisions = await session.Advanced.Revisions.GetForAsync <Company>("companies/1-A");
Assert.Equal(3, companiesRevisions.Count);
var metadatas = companiesRevisions.Select(c => session.Advanced.GetMetadataFor(c)).ToList();
Assert.Equal("HR", companiesRevisions[0].Name);
var revisionCounters = (IMetadataDictionary)metadatas[0][Constants.Documents.Metadata.RevisionCounters];
Assert.Equal(1, revisionCounters.Count);
Assert.Equal(100L, revisionCounters["Likes"]);
Assert.Equal("HR", companiesRevisions[1].Name);
Assert.False(metadatas[1].TryGetValue(Constants.Documents.Metadata.RevisionCounters, out _));
Assert.Null(companiesRevisions[2].Name);
Assert.False(metadatas[1].TryGetValue(Constants.Documents.Metadata.RevisionCounters, out _));
}
using (var session = store.OpenAsyncSession())
{
var company = await session.LoadAsync <Company>("companies/1-A");
// revision 4
company.Name = "Hibernating Rhinos";
await session.SaveChangesAsync();
// revision 5
session.CountersFor(company).Increment("Dislikes", 20);
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var companiesRevisions = await session.Advanced.Revisions.GetForAsync <Company>("companies/1-A");
Assert.Equal(5, companiesRevisions.Count);
var metadatas = companiesRevisions.Select(c => session.Advanced.GetMetadataFor(c)).ToList();
Assert.Equal("Hibernating Rhinos", companiesRevisions[0].Name);
var revisionCounters = (IMetadataDictionary)metadatas[0][Constants.Documents.Metadata.RevisionCounters];
Assert.Equal(2, revisionCounters.Count);
Assert.Equal(150L, revisionCounters["Likes"]);
Assert.Equal(20L, revisionCounters["Dislikes"]);
Assert.Equal("Hibernating Rhinos", companiesRevisions[1].Name);
revisionCounters = (IMetadataDictionary)metadatas[1][Constants.Documents.Metadata.RevisionCounters];
Assert.Equal(1, revisionCounters.Count);
Assert.Equal(150L, revisionCounters["Likes"]);
Assert.Equal("HR", companiesRevisions[2].Name);
revisionCounters = (IMetadataDictionary)metadatas[2][Constants.Documents.Metadata.RevisionCounters];
Assert.Equal(1, revisionCounters.Count);
Assert.Equal(100L, revisionCounters["Likes"]);
Assert.Equal("HR", companiesRevisions[3].Name);
Assert.False(metadatas[3].TryGetValue(Constants.Documents.Metadata.RevisionCounters, out _));
Assert.Null(companiesRevisions[4].Name);
Assert.False(metadatas[4].TryGetValue(Constants.Documents.Metadata.RevisionCounters, out _));
}
}
}
public async Task CanLimitNumberOfRevisionsByAge()
{
var revisionsAgeLimit = TimeSpan.FromSeconds(10);
using (var store = GetDocumentStore())
{
var configuration = new RevisionsConfiguration
{
Collections = new Dictionary <string, RevisionsCollectionConfiguration>
{
["Users"] = new RevisionsCollectionConfiguration
{
Disabled = false,
MinimumRevisionAgeToKeep = revisionsAgeLimit
}
}
};
var index = await RevisionsHelper.SetupRevisions(Server.ServerStore, store.Database, configuration);
var documentDatabase = await Server.ServerStore.DatabasesLandlord.TryGetOrCreateResourceStore(store.Database);
await documentDatabase.RachisLogIndexNotifications.WaitForIndexNotification(index, Server.ServerStore.Engine.OperationTimeout);
using (var session = store.OpenAsyncSession())
{
// revision 1
await session.StoreAsync(new User
{
Name = "Aviv"
}, "users/1-A");
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var user = await session.LoadAsync <User>("users/1-A");
// revision 2
user.Name = "Aviv2";
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var userRevisions = await session.Advanced.Revisions.GetForAsync <User>("users/1-A");
Assert.Equal(2, userRevisions.Count);
Assert.Equal("Aviv2", userRevisions[0].Name);
Assert.Equal("Aviv", userRevisions[1].Name);
}
await Task.Delay(revisionsAgeLimit);
using (var session = store.OpenAsyncSession())
{
var user = await session.LoadAsync <User>("users/1-A");
// revision 3
user.Name = "Aviv3";
// revisions age limit has passed
// should delete the old revisions now
// and keep just this one
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var userRevisions = await session.Advanced.Revisions.GetForAsync <User>("users/1-A");
Assert.Equal(1, userRevisions.Count);
Assert.Equal("Aviv3", userRevisions[0].Name);
}
}
}
public async Task WillDeleteRevisionsIfDeleted_OnlyIfPurgeOnDeleteIsTrue()
{
using (var store = GetDocumentStore())
{
await RevisionsHelper.SetupRevisions(Server.ServerStore, store.Database);
using (var session = store.OpenAsyncSession())
{
var company = new Company {
Name = "Hibernating Rhinos "
};
var user = new User {
Name = "Fitzchak "
};
await session.StoreAsync(company, "companies/1");
await session.StoreAsync(user, "users/1");
await session.SaveChangesAsync();
}
for (int i = 0; i < 10; i++)
{
using (var session = store.OpenAsyncSession())
{
var company = await session.LoadAsync <Company>("companies/1");
var user = await session.LoadAsync <User>("users/1");
company.Name += i;
user.Name += i;
await session.StoreAsync(company);
await session.StoreAsync(user);
await session.SaveChangesAsync();
}
}
using (var session = store.OpenAsyncSession())
{
var company = await session.LoadAsync <Company>("companies/1");
var user = await session.LoadAsync <User>("users/1");
Assert.NotNull(company);
Assert.NotNull(user);
session.Delete(company);
session.Delete(user);
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var companies = await session.Advanced.Revisions.GetForAsync <Company>("companies/1");
var users = await session.Advanced.Revisions.GetForAsync <User>("users/1");
Assert.Equal(5, companies.Count);
Assert.Empty(users);
}
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new Company { Name = "New Company" }, "companies/1");
await session.StoreAsync(new User { Name = "New User" }, "users/1");
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var companies = await session.Advanced.Revisions.GetForAsync <Company>("companies/1");
var users = await session.Advanced.Revisions.GetForAsync <User>("users/1");
Assert.Equal(5, companies.Count);
Assert.Equal("New Company", companies.First().Name);
Assert.Equal(1, users.Count);
}
}
}
