public void CanUseClear()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var user = new User {
Id = "users/1", Name = "John"
};
session.Store(user);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
Assert.Equal(0, session.Advanced.NumberOfRequests);
session.Load <User>("users/1");
Assert.Equal(1, session.Advanced.NumberOfRequests);
session.Load <User>("users/1");
Assert.Equal(1, session.Advanced.NumberOfRequests);
session.Advanced.Clear();
session.Load <User>("users/1");
Assert.Equal(2, session.Advanced.NumberOfRequests);
}
}
}
public void CanUseIsLoaded()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var user = new User {
Id = "users/1", Name = "John"
};
session.Store(user);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
Assert.False(session.Advanced.IsLoaded("users/1"));
session.Load <User>("users/1");
Assert.True(session.Advanced.IsLoaded("users/1"));
Assert.False(session.Advanced.IsLoaded("users/2"));
session.Advanced.Clear();
Assert.False(session.Advanced.IsLoaded("users/1"));
}
}
}
public async Task KeyGeneration()
{
using (var store = GetDocumentStore())
{
store.Conventions.RegisterIdConvention <User>((databaseName, commands, entity) => "abc");
store.Conventions.RegisterAsyncIdConvention <User>((databaseName, commands, entity) => new CompletedTask <string>("def"));
using (var session = store.OpenSession())
{
var user = new User {
Name = "John"
};
session.Store(user);
Assert.Equal("abc", user.Id);
}
using (var session = store.OpenAsyncSession())
{
var user = new User {
Name = "John"
};
await session.StoreAsync(user);
Assert.Equal("def", user.Id);
}
Assert.Equal("abc", store.Conventions.GenerateDocumentKey(store.DefaultDatabase, store.DatabaseCommands, new User()));
Assert.Equal("def", await store.Conventions.GenerateDocumentKeyAsync(store.DefaultDatabase, store.AsyncDatabaseCommands, new User()));
Assert.Equal("addresses/1", store.Conventions.GenerateDocumentKey(store.DefaultDatabase, store.DatabaseCommands, new Address()));
Assert.Equal("companies/1", await store.Conventions.GenerateDocumentKeyAsync(store.DefaultDatabase, store.AsyncDatabaseCommands, new Company()));
}
}
public void BasicInclude()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var user = new User
{
Id = "users/1",
AddressId = "addresses/1",
Name = "John"
};
var address = new Address
{
Id = "addresses/1",
City = "New York",
Country = "USA",
Street = "Wall Street"
};
session.Store(user);
session.Store(address);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
Assert.Equal(0, session.Advanced.NumberOfRequests);
var user = session
.Include <User>(x => x.AddressId)
.Load <User>("users/1");
Assert.Equal(1, session.Advanced.NumberOfRequests);
Assert.NotNull(user);
Assert.Equal("John", user.Name);
var address = session.Load <Address>(user.AddressId);
Assert.Equal(1, session.Advanced.NumberOfRequests);
Assert.Equal("New York", address.City);
}
}
}
public void CanUseRefresh()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var user = new User {
Id = "users/1", Name = "John"
};
session.Store(user);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var user = session.Load <User>("users/1");
Assert.NotNull(user);
Assert.Equal("John", user.Name);
using (var otherSession = store.OpenSession())
{
var u = otherSession.Load <User>("users/1");
u.Name = "Jonathan";
otherSession.SaveChanges();
}
using (var otherSession = store.OpenSession())
{
var u = otherSession.Load <User>("users/1");
Assert.Equal("Jonathan", u.Name);
}
user = session.Load <User>("users/1");
Assert.NotNull(user);
Assert.Equal("John", user.Name);
session.Advanced.Refresh(user);
Assert.NotNull(user);
Assert.Equal("Jonathan", user.Name);
}
}
}
public void CanGetChangesInformation()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
Assert.False(session.Advanced.HasChanges);
var user = new User {
Id = "users/1", Name = "John"
};
session.Store(user);
Assert.True(session.Advanced.HasChanged(user));
var x = session.Advanced.HasChanges;
Assert.True(session.Advanced.HasChanges);
session.SaveChanges();
Assert.False(session.Advanced.HasChanged(user));
Assert.False(session.Advanced.HasChanges);
user.AddressId = "addresses/1";
Assert.True(session.Advanced.HasChanged(user));
Assert.True(session.Advanced.HasChanges);
var whatChanged = session.Advanced.WhatChanged();
Assert.Equal("AddressId", ((DocumentsChanges[])whatChanged["users/1"])[0].FieldName);
Assert.Equal(null, ((DocumentsChanges[])whatChanged["users/1"])[0].FieldOldValue);
Assert.Equal("addresses/1", ((DocumentsChanges[])whatChanged["users/1"])[0].FieldNewValue.ToString());
session.Advanced.Clear();
Assert.False(session.Advanced.HasChanges);
var user2 = new User {
Id = "users/2", Name = "John"
};
session.Store(user2);
session.Delete(user2);
Assert.True(session.Advanced.HasChanged(user2));
Assert.True(session.Advanced.HasChanges);
}
}
}
public void StoringDocumentWithTheSameIdInTheSameSessionShouldThrow()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var user = new User { Id = "users/1", Name = "User1" };
session.Store(user);
session.SaveChanges();
user = new User { Id = "users/1", Name = "User2" };
var e = Assert.Throws<NonUniqueObjectException>(() => session.Store(user));
Assert.Equal("Attempted to associate a different object with id 'users/1'.", e.Message);
}
}
}
public void CanStreamDocumentsFromSpecifiedEtag()
{
using (var store = GetDocumentStore())
{
long?fromEtag;
using (var session = store.OpenSession())
{
User hundredthUser = null;
for (int i = 0; i < 200; i++)
{
var user = new User();
session.Store(user);
if (i == 99)
{
hundredthUser = user;
}
}
session.SaveChanges();
fromEtag = session.Advanced.GetEtagFor(hundredthUser);
}
int count = 0;
using (var session = store.OpenSession())
{
using (var reader = session.Advanced.Stream <User>(fromEtag: fromEtag))
{
while (reader.MoveNext())
{
count++;
Assert.IsType <User>(reader.Current.Document);
}
}
}
Assert.Equal(100, count);
}
}
public void CanUseRefresh()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var user = new User {
Id = "users/1", Name = "John"
};
session.Store(user);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var user = session.Load <User>("users/1");
Assert.NotNull(user);
Assert.Equal("John", user.Name);
DocumentInfo documentInfo;
var document = GetCommand(session, new[] { "users/1" }, out documentInfo);
documentInfo.Entity = session.Advanced.ConvertToEntity(typeof(User), "users/1", document);
((User)documentInfo.Entity).Name = "Jonathan";
PutCommand(session, documentInfo.Entity, "users/1");
user = session.Load <User>("users/1");
Assert.NotNull(user);
Assert.Equal("John", user.Name);
session.Advanced.Refresh(user);
Assert.NotNull(user);
Assert.Equal("Jonathan", user.Name);
}
}
}
public async Task CanDelete()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenAsyncSession())
{
var entity1 = new User {
Name = "Andy A"
};
var entity2 = new User {
Name = "Andy B"
};
var entity3 = new User {
Name = "Andy C"
};
await session.StoreAsync(entity1);
await session.StoreAsync(entity2);
await session.StoreAsync(entity3);
await session.SaveChangesAsync();
session.Delete(entity1);
session.Delete("users/2");
session.Delete("users/3");
await session.SaveChangesAsync();
var users = await session.LoadAsync <User>(new[] { "users/1", "users/2", "users/3" });
foreach (var user in users)
{
Assert.Null(user.Value);
}
}
}
}
public async Task KeyGeneration()
{
using (var store = GetDocumentStore(new Options
{
ModifyDocumentStore = s =>
{
s.Conventions.RegisterAsyncIdConvention <User>((databaseName, entity) => Task.FromResult("def/" + entity.Name));
}
}))
{
using (var session = store.OpenSession())
{
var user = new User {
Name = "John"
};
session.Store(user);
Assert.Equal("def/John", user.Id);
}
using (var session = store.OpenAsyncSession())
{
var user = new User {
Name = "Bob"
};
await session.StoreAsync(user);
Assert.Equal("def/Bob", user.Id);
}
Assert.Equal("def/", store.Conventions.GenerateDocumentId(store.Database, new User()));
Assert.Equal("def/", await store.Conventions.GenerateDocumentIdAsync(store.Database, new User()));
Assert.Equal("addresses/1-A", store.Conventions.GenerateDocumentId(store.Database, new Address()));
Assert.Equal("companies/1-A", await store.Conventions.GenerateDocumentIdAsync(store.Database, new Company()));
}
}
public void CanUseRefresh()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var user = new User {
Id = "users/1", Name = "John"
};
session.Store(user);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var user = session.Load <User>("users/1");
Assert.NotNull(user);
Assert.Equal("John", user.Name);
var u = store.DatabaseCommands.Get("users/1");
u.DataAsJson["Name"] = "Jonathan";
store.DatabaseCommands.Put("users/1", u.Etag, u.DataAsJson, u.Metadata);
user = session.Load <User>("users/1");
Assert.NotNull(user);
Assert.Equal("John", user.Name);
session.Advanced.Refresh(user);
Assert.NotNull(user);
Assert.Equal("Jonathan", user.Name);
}
}
}
