public void DeleteBulk(TestSessionWrapper wrapper)
{
wrapper.Session.Delete <User>(u => u.Username == "BulkDelete");
var users = wrapper.Session.Query <User>().Where(u => u.Username == "BulkDelete");
Assert.Empty(users);
}
public void WhereEnumerableWorks(TestSessionWrapper wrapper)
{
var ids = new long[] { 1, 2, 3 };
var posts = wrapper.Session.Query <Post>().Where(p => ids.Contains(p.PostId)).ToList();
Assert.Equal(3, posts.Count);
}
public void MultipleFetchParentWorks(TestSessionWrapper wrapper)
{
var posts = wrapper.Session.Query <PostTag>().Fetch(p => p.Post).Fetch(p => p.Tag).OrderBy(p => p.PostTagId).ToList();
Assert.NotNull(posts.First().Post.Title);
Assert.NotNull(posts.First().Tag.Content);
}
public async Task DynamicQueryAsyncWorks(TestSessionWrapper wrapper)
{
var result = await wrapper.Session.Dapper.QueryAsync("select 1 as Id");
Assert.Single(result);
Assert.Equal(1, result.First().Id);
}
public void OuterJoinDisjunctionWorks(TestSessionWrapper wrapper)
{
var posts = wrapper.Session.Query <Post>()
.Where(p => p.Blog.Title == "Blog_1" || p.Blog.Title == "Blog_2");
Assert.NotEmpty(posts);
}
public void TestSingleAndFirst(TestSessionWrapper wrapper)
{
// now fetch them
var t1 = wrapper.Session.Query <User>().First();
Assert.Equal("User_0", t1.Username);
var t2 = wrapper.Session.Query <User>().First(u => u.Username == "User_1");
Assert.Equal("User_1", t2.Username);
Assert.Throws <InvalidOperationException>(() => wrapper.Session.Query <User>().Single());
var t3 = wrapper.Session.Query <User>().Single(u => u.Username == "User_2");
Assert.Equal("User_2", t3.Username);
var t4 = wrapper.Session.Query <User>().FirstOrDefault();
Assert.Equal("User_0", t1.Username);
var t5 = wrapper.Session.Query <User>().FirstOrDefault(u => u.Username == "Boo");
Assert.Null(t5);
var t6 = wrapper.Session.Query <User>().SingleOrDefault(u => u.Username == "Boo");
Assert.Null(t6);
}
public void TestChainedCollectionFetch(TestSessionWrapper wrapper)
{
var blog = wrapper.Session.Query <Blog>().FetchMany(p => p.Posts).ThenFetch(p => p.Comments).First();
Assert.Equal(2, blog.Posts.Count);
Assert.Equal(3, blog.Posts.First().Comments.Count);
}
public void TestDelete(TestSessionWrapper wrapper)
{
var user = wrapper.Session.Query <User>().First(u => u.Username == "TestDelete");
wrapper.Session.Delete(user);
Assert.Empty(wrapper.Session.Query <User>().Where(u => u.Username == "TestDelete"));
}
public void UpdateBulk(TestSessionWrapper wrapper)
{
wrapper.Session.Update <User>(u => u.Password = "******", u => u.Username == "BulkUpdate");
var user = wrapper.Session.Query <User>().First(u => u.Username == "BulkUpdate");
Assert.Equal("boo", user.Password);
}
public void MultipleFetchWithNestedWorks(TestSessionWrapper wrapper)
{
var comment = wrapper.Session.Query <Comment>().Fetch(c => c.Post.Blog).Fetch(c => c.User).OrderBy(c => c.CommentId);
Assert.NotNull(comment.First().Post.Blog.Title);
Assert.NotNull(comment.First().User.Username);
}
public void TestMultiCollectionFetch(TestSessionWrapper wrapper)
{
var posts = wrapper.Session.Query <Post>().Fetch(p => p.Comments).Fetch(p => p.Tags).Where(p => p.PostId == 1).ToList();
Assert.True(posts.First().Comments.Count == 3);
Assert.True(posts.First().Tags.Count == 2);
}
public async Task StronglyTypedQueryWorks(TestSessionWrapper wrapper)
{
var result = await wrapper.Session.Dapper.QueryAsync <Foo>("select 1 as FooId, 'Rah' as Bar");
Assert.Single(result);
Assert.Equal(1, result.First().FooId);
Assert.Equal("Rah", result.First().Bar);
}
public void TestCollectionFetch(TestSessionWrapper wrapper)
{
var posts = wrapper.Session.Query <Post>().Fetch(p => p.Comments).ToList();
Assert.True(
posts.First(p => p.PostId == 1)
.Comments.Count(c => c.Content == "Comment_0" || c.Content == "Comment_1" || c.Content == "Nullable User Content") == 3);
}
public void FetchRelationIdWorks(TestSessionWrapper wrapper)
{
var blogs = wrapper.Session.Query <Post>()
.Select(p => p.Blog.BlogId)
.AsPaged(10, 10);
Assert.Equal(10, blogs.Taken);
Assert.True(blogs.TotalResults > 10);
}
public void TestInsertGetsId(TestSessionWrapper wrapper)
{
var user = new User {
Username = "******", EmailAddress = Guid.NewGuid().ToString(), Password = "******"
};
wrapper.Session.Insert(user);
Assert.NotEqual(0, user.UserId);
}
public void FetchSinglePropWorks(TestSessionWrapper wrapper)
{
var posts = wrapper.Session.Query <Post>()
.Select(p => p.PostId)
.AsPaged(10, 10);
Assert.Equal(10, posts.Taken);
Assert.True(posts.TotalResults > 10);
}
public async Task InsertWorks(TestSessionWrapper wrapper)
{
var comment = new Comment {
Content = "Foo"
};
await wrapper.Session.InsertAsync(comment);
Assert.NotEqual(0, comment.CommentId);
}
public async Task InsertAsyncEnablesTracking(TestSessionWrapper wrapper)
{
var user = new User {
Username = "******", EmailAddress = Guid.NewGuid().ToString(), Password = "******"
};
await wrapper.Session.InsertAsync(user);
Assert.True(((ITrackedEntity)user).IsTrackingEnabled());
}
public void TestUpdate(TestSessionWrapper wrapper)
{
var user = wrapper.Session.Query <User>().First();
user.HeightInMeters = 1.7m;
wrapper.Session.Save(user);
var dbUser = wrapper.Session.Get <User>(user.UserId);
Assert.Equal(1.7m, dbUser.HeightInMeters);
}
public void FetchProjectionPagedWorks(TestSessionWrapper wrapper)
{
var posts = wrapper.Session.Query <Post>()
.Select(p => new { p.Title, BlogTitle = p.Blog.Title })
.AsPaged(10, 10);
Assert.Equal(10, posts.Taken);
Assert.True(posts.TotalResults > 10);
Assert.NotNull(posts.Items.ElementAt(0).Title);
Assert.NotNull(posts.Items.ElementAt(0).BlogTitle);
}
public void NoFetchProjectionWorks(TestSessionWrapper wrapper)
{
var ids = new long[] { 1, 2, 3 };
var posts = wrapper.Session.Query <Post>()
.Where(p => ids.Contains(p.PostId))
.Select(p => new { p.Title })
.ToList();
Assert.Equal(3, posts.Count);
Assert.NotNull(posts[0].Title);
}
public void TestInsert(TestSessionWrapper wrapper)
{
var user = new User {
Username = "******", EmailAddress = Guid.NewGuid().ToString(), Password = "******"
};
wrapper.Session.Insert(user);
var dbUser = wrapper.Session.Query <User>().First(u => u.EmailAddress == user.EmailAddress);
Assert.NotNull(dbUser);
}
public void TestManyFetches(TestSessionWrapper wrapper)
{
var post =
wrapper.Session.Query <Post>()
.FetchMany(p => p.Comments)
.ThenFetch(c => c.User)
.Fetch(p => p.Blog)
.Fetch(p => p.Author)
.SingleOrDefault(p => p.PostId == 1);
Assert.True(post != null);
}
public void TestManyToManyThing(TestSessionWrapper wrapper)
{
var post =
wrapper.Session.Query <Post>()
.FetchMany(p => p.Tags)
.ThenFetch(t => t.Tag)
.Fetch(p => p.Blog)
.Fetch(p => p.Author)
.SingleOrDefault(p => p.PostId == 1);
Assert.True(post != null);
}
public void FetchRelationPropWorks(TestSessionWrapper wrapper)
{
var blogs = wrapper.Session.Query <Post>()
.Select(p => p.Blog)
.AsPaged(10, 10);
Assert.Equal(10, blogs.Taken);
Assert.True(blogs.TotalResults > 10);
Assert.NotNull(
blogs.Items.First()
.Title);
}
public void DateTimeInsertedAndSelectedCorrectly(TestSessionWrapper wrapper)
{
var date = new DateTime(2016, 12, 25, 1, 3, 6, DateTimeKind.Utc);
var comment = new Comment {
Content = "Foo", CommentDate = date
};
wrapper.Session.Insert(comment);
Assert.Equal(date, comment.CommentDate);
var fetchedComment = wrapper.Session.Get <Comment>(comment.CommentId);
Assert.Equal(date, fetchedComment.CommentDate);
}
public void TestMultipleInsertUpdatesIds(TestSessionWrapper wrapper)
{
var user = new User {
Username = "******", EmailAddress = "asd", Password = "******"
};
var user2 = new User {
Username = "******", EmailAddress = "asd", Password = "******"
};
wrapper.Session.Insert(user, user2);
Assert.NotEqual(0, user.UserId);
Assert.NotEqual(0, user2.UserId);
Assert.NotEqual(user.UserId, user2.UserId);
}
public void MultipleFetchManyWithNonRootAndThenFetchWorks(TestSessionWrapper wrapper)
{
var responses =
wrapper.Session.Query <QuestionnaireResponse>()
.Where(qr => qr.Questionnaire.QuestionnaireId == 1)
.Fetch(qr => qr.Questionnaire)
.FetchMany(qr => qr.Responses)
.ThenFetch(qrr => qrr.Question)
.FetchMany(qr => qr.Booking.Beds)
.ThenFetch(b => b.RoomSlot.Room)
.ToArray();
Assert.Single(responses);
Assert.Equal(1, responses.First().Booking.Beds.Count);
}
public void FetchWithNonFetchedWhere(TestSessionWrapper wrapper)
{
var comment = wrapper.Session.Query <Comment>().Fetch(c => c.Post.Blog).Where(c => c.User.EmailAddress == "foo");
Assert.Null(comment.FirstOrDefault());
}
public void TestFetchingEmptyCollection(TestSessionWrapper wrapper)
{
var emptyBlog = wrapper.Session.Query <Blog>().First(b => b.Title == "EmptyBlog");
Assert.Empty(emptyBlog.Posts);
}